Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around ()
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void open_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 790 of file game.h.

790 : int {
791 CHANGE_TAB,
792 QUIT,
793 FIRE, // Who knew, apparently you can do that in list_monsters
794 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 287 of file game.cpp.

287 :
289 scent_ptr( *this ),
292 m( *map_ptr ),
293 u( *u_ptr ),
294 scent( *scent_ptr ),
296 uquit( QUIT_NO ),
297 new_game( false ),
299 mostseen( 0 ),
302 next_npc_id( 1 ),
303 next_mission_id( 1 ),
307 seed( 0 ),
308 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
309{
317 world_generator = std::make_unique<worldfactory>();
318 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
319 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
320}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1044
pimpl< spell_events > spell_events_ptr
Definition: game.h:979
safe_mode_type safe_mode
Definition: game.h:1041
bool safe_mode_warning_logged
Definition: game.h:1055
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:973
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1089
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:999
event_bus & events()
Definition: game.cpp:2850
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:975
character_id next_npc_id
Definition: game.h:1057
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:977
void reset_light_level()
Definition: game.cpp:3694
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:978
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1046
pimpl< map > map_ptr
Definition: game.h:968
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1072
pimpl< live_view > liveview_ptr
Definition: game.h:970
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:976
pimpl< scent_map > scent_ptr
Definition: game.h:972
timed_event_manager & timed_events
Definition: game.h:987
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1084
int next_mission_id
Definition: game.h:1059
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1001
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:980
map & m
Definition: game.h:984
avatar & u
Definition: game.h:985
scent_map & scent
Definition: game.h:986
int user_action_counter
Definition: game.h:1078
live_view & liveview
Definition: game.h:971
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1081
pimpl< avatar > u_ptr
Definition: game.h:969
time_point remoteveh_cache_time
Definition: game.h:1065
static void achievement_attained(const achievement *a)
Definition: game.cpp:280
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 11853 of file game.cpp.

11854{
11855 //If player is sleeping, get a dream from a carried artifact
11856 //Don't need to check that player is sleeping here, that's done before calling
11857 std::list<item *> art_items = g->u.get_artifact_items();
11858 std::vector<item *> valid_arts;
11859 std::vector<std::vector<std::string>>
11860 valid_dreams; // Tracking separately so we only need to check its req once
11861 //Pull the list of dreams
11862 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
11863 for( auto &it : art_items ) {
11864 //Pick only the ones with an applicable dream
11865 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
11866 if( art && art->charge_req != ACR_NULL &&
11867 ( it->ammo_remaining() < it->ammo_capacity() ||
11868 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
11869 add_msg( m_debug, "Checking artifact %s", it->tname() );
11870 if( check_art_charge_req( *it ) ) {
11871 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11872 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
11873 add_msg( m_debug, "Adding met dream from %s", it->tname() );
11874 valid_arts.push_back( it );
11875 valid_dreams.push_back( art->dream_msg_met );
11876 }
11877 } else {
11878 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11879 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
11880 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
11881 valid_arts.push_back( it );
11882 valid_dreams.push_back( art->dream_msg_unmet );
11883 }
11884 }
11885 }
11886 }
11887 if( !valid_dreams.empty() ) {
11888 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
11889 const int selected = rng( 0, valid_arts.size() - 1 );
11890 auto it = valid_arts[selected];
11891 auto msg = random_entry( valid_dreams[selected] );
11892 const std::string &dream = string_format( _( msg ), it->tname() );
11893 add_msg( dream );
11894 } else {
11895 add_msg( m_debug, "Didn't have any dreams, sorry" );
11896 }
11897}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:264
std::unique_ptr< game > g
Definition: game.cpp:270
bool check_art_charge_req(item &it)
Definition: game.cpp:11556
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 11675 of file game.cpp.

11676{
11677 int net_str = 0;
11678 int net_dex = 0;
11679 int net_per = 0;
11680 int net_int = 0;
11681 int net_speed = 0;
11682
11683 for( auto &i : effects ) {
11684 switch( i ) {
11685 case AEP_STR_UP:
11686 net_str += 4;
11687 break;
11688 case AEP_DEX_UP:
11689 net_dex += 4;
11690 break;
11691 case AEP_PER_UP:
11692 net_per += 4;
11693 break;
11694 case AEP_INT_UP:
11695 net_int += 4;
11696 break;
11697 case AEP_ALL_UP:
11698 net_str += 2;
11699 net_dex += 2;
11700 net_per += 2;
11701 net_int += 2;
11702 break;
11703 case AEP_STR_DOWN:
11704 net_str -= 3;
11705 break;
11706 case AEP_DEX_DOWN:
11707 net_dex -= 3;
11708 break;
11709 case AEP_PER_DOWN:
11710 net_per -= 3;
11711 break;
11712 case AEP_INT_DOWN:
11713 net_int -= 3;
11714 break;
11715 case AEP_ALL_DOWN:
11716 net_str -= 2;
11717 net_dex -= 2;
11718 net_per -= 2;
11719 net_int -= 2;
11720 break;
11721
11722 case AEP_SPEED_UP:
11723 net_speed += 20;
11724 break;
11725 case AEP_SPEED_DOWN:
11726 net_speed -= 20;
11727 break;
11728
11729 case AEP_PBLUE:
11730 break; // No message
11731
11732 case AEP_SNAKES:
11733 add_msg( m_warning, _( "Your skin feels slithery." ) );
11734 break;
11735
11736 case AEP_INVISIBLE:
11737 add_msg( m_good, _( "You fade into invisibility!" ) );
11738 break;
11739
11740 case AEP_CLAIRVOYANCE:
11742 add_msg( m_good, _( "You can see through walls!" ) );
11743 break;
11744
11746 add_msg( m_good, _( "You can see through everything!" ) );
11747 break;
11748
11749 case AEP_STEALTH:
11750 add_msg( m_good, _( "Your steps stop making noise." ) );
11751 break;
11752
11753 case AEP_GLOW:
11754 add_msg( _( "A glow of light forms around you." ) );
11755 break;
11756
11757 case AEP_PSYSHIELD:
11758 add_msg( m_good, _( "Your mental state feels protected." ) );
11759 break;
11760
11762 add_msg( m_good, _( "You feel insulated." ) );
11763 break;
11764
11765 case AEP_CARRY_MORE:
11766 add_msg( m_good, _( "Your back feels strengthened." ) );
11767 break;
11768
11769 case AEP_FUN:
11770 add_msg( m_good, _( "You feel a pleasant tingle." ) );
11771 break;
11772
11773 case AEP_HUNGER:
11774 add_msg( m_warning, _( "You feel hungry." ) );
11775 break;
11776
11777 case AEP_THIRST:
11778 add_msg( m_warning, _( "You feel thirsty." ) );
11779 break;
11780
11781 case AEP_EVIL:
11782 add_msg( m_warning, _( "You feel an evil presence…" ) );
11783 break;
11784
11785 case AEP_SCHIZO:
11786 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
11787 break;
11788
11789 case AEP_RADIOACTIVE:
11790 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
11791 break;
11792
11793 case AEP_MUTAGENIC:
11794 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
11795 break;
11796
11797 case AEP_ATTENTION:
11798 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
11799 break;
11800
11801 case AEP_FORCE_TELEPORT:
11802 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
11803 break;
11804
11805 case AEP_MOVEMENT_NOISE:
11806 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
11807 break;
11808
11809 case AEP_BAD_WEATHER:
11810 add_msg( m_warning, _( "You feel storms coming." ) );
11811 break;
11812
11813 case AEP_SICK:
11814 add_msg( m_bad, _( "You feel unwell." ) );
11815 break;
11816
11817 case AEP_SMOKE:
11818 add_msg( m_warning, _( "A cloud of smoke appears." ) );
11819 break;
11820 default:
11821 //Suppress warnings
11822 break;
11823 }
11824 }
11825
11826 std::string stat_info;
11827 if( net_str != 0 ) {
11828 stat_info += string_format( _( "Str %s%d! " ),
11829 ( net_str > 0 ? "+" : "" ), net_str );
11830 }
11831 if( net_dex != 0 ) {
11832 stat_info += string_format( _( "Dex %s%d! " ),
11833 ( net_dex > 0 ? "+" : "" ), net_dex );
11834 }
11835 if( net_int != 0 ) {
11836 stat_info += string_format( _( "Int %s%d! " ),
11837 ( net_int > 0 ? "+" : "" ), net_int );
11838 }
11839 if( net_per != 0 ) {
11840 stat_info += string_format( _( "Per %s%d! " ),
11841 ( net_per > 0 ? "+" : "" ), net_per );
11842 }
11843
11844 if( !stat_info.empty() ) {
11845 add_msg( m_neutral, stat_info );
11846 }
11847
11848 if( net_speed != 0 ) {
11849 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
11850 }
11851}
@ m_good
Definition: enums.h:253
@ m_neutral
Definition: enums.h:260
@ m_info
Definition: enums.h:258
@ m_bad
Definition: enums.h:254
@ m_warning
Definition: enums.h:257
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3145 of file game.cpp.

3146{
3147 draw_callbacks.erase(
3148 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3149 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3150 return cbw.expired();
3151 } ),
3152 draw_callbacks.end()
3153 );
3154 draw_callbacks.emplace_back( cb );
3155 cb->added = true;
3157}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3110
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1961 of file game.cpp.

1962{
1963 follower_ids.insert( id );
1964 u.follower_ids.insert( id );
1965}
std::set< character_id > follower_ids
Definition: game.h:1060
std::set< character_id > follower_ids
Definition: player.h:627

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12009 of file game.cpp.

12010{
12011 return Creature_range( *this );
12012}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12014 of file game.cpp.

12015{
12016 return monster_range( *this );
12017}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12019 of file game.cpp.

12020{
12021 return npc_range( *this );
12022}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 11923 of file game.cpp.

11924{
11925 return get_npcs_if( [&]( const npc & guy ) {
11926 if( !guy.is_hallucination() ) {
11927 return guy.is_ally( g->u );
11928 } else {
11929 return false;
11930 }
11931 } );
11932}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:11946
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3260

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1949 of file game.cpp.

1950{
1951 int ret = next_mission_id;
1953 return ret;
1954}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3702 of file game.cpp.

3703{
3705 ++next_npc_id;
3706 return ret;
3707}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1754 of file game.cpp.

1755{
1756 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1757 vehicle *&v = veh.v;
1758 if( v->is_following ) {
1759 v->drive_to_local_target( m.getabs( u.pos() ), true );
1760 } else if( v->is_patrolling ) {
1761 v->autopilot_patrol();
1762 }
1763 }
1764}
const tripoint & pos() const override
Definition: character.cpp:714
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8215
VehicleList get_vehicles()
Definition: map.cpp:233
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1983
bool is_patrolling
Definition: vehicle.h:1984
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11342 of file game.cpp.

11343{
11344 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11345 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11346 return;
11347 }
11348 quicksave(); //Driving checks are handled by quicksave()
11349}
time_t last_save_timestamp
Definition: game.h:1062
void quicksave()
Definition: game.cpp:11297

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8339 of file game.cpp.

8340{
8341 static const std::string salvage_string = "salvage";
8342 if( u.controlling_vehicle ) {
8343 add_msg( m_info, _( "You can't butcher while driving!" ) );
8344 return;
8345 }
8346
8347 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8348 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8349 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8350 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8351
8352 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8353 if( m.has_flag( "SEALED", u.pos() ) ) {
8354 if( m.sees_some_items( u.pos(), u ) ) {
8355 add_msg( m_info, _( "You can't access the items here." ) );
8356 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8357 add_msg( m_info, no_corpse_msg );
8358 } else {
8359 add_msg( m_info, no_knife_msg );
8360 }
8361 return;
8362 }
8363
8364 const item *first_item_without_tools = nullptr;
8365 // Indices of relevant items
8366 std::vector<map_stack::iterator> corpses;
8367 std::vector<map_stack::iterator> disassembles;
8368 std::vector<map_stack::iterator> salvageables;
8369 map_stack items = m.i_at( u.pos() );
8370 const inventory &crafting_inv = u.crafting_inventory();
8371
8372 // TODO: Properly handle different material whitelists
8373 // TODO: Improve quality of this section
8374 auto salvage_filter = []( item it ) {
8375 const auto usable = it.get_usable_item( salvage_string );
8376 return usable != nullptr;
8377 };
8378
8379 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8380 int salvage_tool_index = INT_MIN;
8381 item *salvage_tool = nullptr;
8382 const salvage_actor *salvage_iuse = nullptr;
8383 if( !salvage_tools.empty() ) {
8384 salvage_tool = salvage_tools.front();
8385 salvage_tool_index = u.get_item_position( salvage_tool );
8386 item *usable = salvage_tool->get_usable_item( salvage_string );
8387 salvage_iuse = dynamic_cast<const salvage_actor *>(
8388 usable->get_use( salvage_string )->get_actor_ptr() );
8389 }
8390
8391 // Reserve capacity for each to hold entire item set if necessary to prevent
8392 // reallocations later on
8393 corpses.reserve( items.size() );
8394 salvageables.reserve( items.size() );
8395 disassembles.reserve( items.size() );
8396
8397 // Split into corpses, disassemble-able, and salvageable items
8398 // It's not much additional work to just generate a corpse list and
8399 // clear it later, but does make the splitting process nicer.
8400 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8401 if( it->is_corpse() ) {
8402 corpses.push_back( it );
8403 } else {
8404 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8405 salvageables.push_back( it );
8406 }
8407 if( u.can_disassemble( *it, crafting_inv ).success() ) {
8408 disassembles.push_back( it );
8409 } else if( !first_item_without_tools ) {
8410 first_item_without_tools = &*it;
8411 }
8412 }
8413 }
8414
8415 // Clear corpses if butcher and dissect factors are INT_MIN
8416 if( factor == INT_MIN && factorD == INT_MIN ) {
8417 corpses.clear();
8418 }
8419
8420 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8421 if( factor > INT_MIN || factorD > INT_MIN ) {
8422 add_msg( m_info, no_corpse_msg );
8423 } else {
8424 add_msg( m_info, no_knife_msg );
8425 }
8426
8427 if( first_item_without_tools ) {
8428 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8429 // Just for the "You need x to disassemble y" messages
8430 const auto ret = u.can_disassemble( *first_item_without_tools, crafting_inv );
8431 if( !ret.success() ) {
8432 add_msg( m_info, "%s", ret.c_str() );
8433 }
8434 }
8435 return;
8436 }
8437
8438 Creature *hostile_critter = is_hostile_very_close();
8439 if( hostile_critter != nullptr ) {
8440 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8441 hostile_critter->disp_name() ) ) {
8442 return;
8443 }
8444 }
8445
8446 // Magic indices for special butcher options
8447 enum : int {
8448 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8449 MULTIBUTCHER,
8450 MULTIDISASSEMBLE_ONE,
8451 MULTIDISASSEMBLE_ALL,
8452 NUM_BUTCHER_ACTIONS
8453 };
8454 // What are we butchering (i.e.. which vector to pick indices from)
8455 enum {
8456 BUTCHER_CORPSE,
8457 BUTCHER_DISASSEMBLE,
8458 BUTCHER_SALVAGE,
8459 BUTCHER_OTHER // For multisalvage etc.
8460 } butcher_select = BUTCHER_CORPSE;
8461 // Index to std::vector of iterators...
8462 int indexer_index = 0;
8463
8464 // Generate the indexed stacks so we can display them nicely
8465 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8466 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8467 // Always ask before cutting up/disassembly, but not before butchery
8468 size_t ret = 0;
8469 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8470 uilist kmenu;
8471 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8472
8473 size_t i = 0;
8474 // Add corpses, disassembleables, and salvagables to the UI
8475 add_corpses( kmenu, corpses, i );
8476 add_disassemblables( kmenu, disassembly_stacks, i );
8477 if( salvage_iuse && !salvageables.empty() ) {
8478 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8479 }
8480
8481 if( corpses.size() > 1 ) {
8482 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8483 }
8484 if( disassembles.size() > 1 ) {
8485 int time_to_disassemble = 0;
8486 int time_to_disassemble_all = 0;
8487 for( const auto &stack : disassembly_stacks ) {
8488 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8489 time_to_disassemble += time;
8490 time_to_disassemble_all += time * stack.second;
8491 }
8492
8493 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8494 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8495 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8496 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8497 }
8498 if( salvage_iuse && salvageables.size() > 1 ) {
8499 int time_to_salvage = 0;
8500 for( const auto &stack : salvage_stacks ) {
8501 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8502 }
8503
8504 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8505 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8506 }
8507
8508 kmenu.query();
8509
8510 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8511 return;
8512 }
8513
8514 ret = static_cast<size_t>( kmenu.ret );
8515 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8516 butcher_select = BUTCHER_OTHER;
8517 indexer_index = ret;
8518 } else if( ret < corpses.size() ) {
8519 butcher_select = BUTCHER_CORPSE;
8520 indexer_index = ret;
8521 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8522 butcher_select = BUTCHER_DISASSEMBLE;
8523 indexer_index = ret - corpses.size();
8524 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8525 butcher_select = BUTCHER_SALVAGE;
8526 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8527 } else {
8528 debugmsg( "Invalid butchery index: %d", ret );
8529 return;
8530 }
8531 }
8532
8533 if( !u.has_morale_to_craft() ) {
8534 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8535 add_msg( m_info,
8536 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8537 } else {
8538 add_msg( m_info,
8539 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8540 }
8541 return;
8542 }
8543 const auto helpers = u.get_crafting_helpers( 3 );
8544 for( const npc *np : helpers ) {
8545 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8546 }
8547 switch( butcher_select ) {
8548 case BUTCHER_OTHER:
8549 switch( indexer_index ) {
8550 case MULTISALVAGE:
8551 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8552 break;
8553 case MULTIBUTCHER:
8554 butcher_submenu( corpses );
8555 for( map_stack::iterator &it : corpses ) {
8556 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8557 }
8558 break;
8559 case MULTIDISASSEMBLE_ONE:
8560 u.disassemble_all( true );
8561 break;
8562 case MULTIDISASSEMBLE_ALL:
8563 u.disassemble_all( false );
8564 break;
8565 default:
8566 debugmsg( "Invalid butchery type: %d", indexer_index );
8567 return;
8568 }
8569 break;
8570 case BUTCHER_CORPSE: {
8571 butcher_submenu( corpses, indexer_index );
8572 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8573 }
8574 break;
8575 case BUTCHER_DISASSEMBLE: {
8576 // Pick index of first item in the disassembly stack
8577 item *const target = &*disassembly_stacks[indexer_index].first;
8578 u.disassemble( item_location( map_cursor( u.pos() ), target ), true );
8579 }
8580 break;
8581 case BUTCHER_SALVAGE: {
8582 if( !salvage_iuse || !salvage_tool ) {
8583 debugmsg( "null salve_iuse or salvage_tool" );
8584 } else {
8585 // Pick index of first item in the salvage stack
8586 item *const target = &*salvage_stacks[indexer_index].first;
8587 item_location item_loc( map_cursor( u.pos() ), target );
8588 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8589 }
8590 }
8591 break;
8592 }
8593}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:228
player_activity activity
Definition: character.h:1516
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2407
bool has_morale_to_craft() const
Definition: crafting.cpp:336
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:554
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9187
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3716
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:176
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7806
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7780
Definition: map.h:101
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2288
map_stack i_at(const tripoint &p)
Definition: map.cpp:4069
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4715
std::vector< item_location > targets
void disassemble_all(bool one_pass)
Definition: crafting.cpp:2051
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2333
ret_val< bool > can_disassemble(const item &obj, const inventory &inv) const
Check if the player can disassemble an item using the current crafting inventory.
Definition: crafting.cpp:1876
bool disassemble()
Definition: crafting.cpp:1949
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:952
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:932
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8189
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8147
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8168
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8100
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8135
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:828
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:314
string_id< quality > quality_id
Definition: type_id.h:174

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), player::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, player::disassemble(), player::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1335 of file game.cpp.

1336{
1337 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1339 return;
1340 }
1341 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1342 const int light_sight_range = u.sight_range( g_light_level );
1343 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1344
1345 // The maximal offset will leave at least this many tiles
1346 // between the PC and the edge of the main window.
1347 static const int border_range = 2;
1348 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1349 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1350
1351 // velocity at or below this results in no offset at all
1352 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1353 // velocity at or above this results in maximal offset
1354 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1356 float velocity = veh->velocity;
1357 rl_vec2d offset = veh->move_vec();
1358 if( !veh->skidding && veh->player_in_control( u ) &&
1359 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1360 // Use the cruise controlled velocity, but only if
1361 // it is not too different from the actual velocity.
1362 // The actual velocity changes too often (see above slowdown).
1363 // Using it makes would make the offset change far too often.
1364 offset = veh->face_vec();
1365 velocity = veh->cruise_velocity;
1366 }
1367 float rel_offset;
1368 if( std::fabs( velocity ) < min_offset_vel ) {
1369 rel_offset = 0;
1370 } else if( std::fabs( velocity ) > max_offset_vel ) {
1371 rel_offset = ( velocity > 0 ) ? 1 : -1;
1372 } else {
1373 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1374 }
1375 // Squeeze into the corners, by making the offset vector longer,
1376 // the PC is still in view as long as both offset.x and
1377 // offset.y are <= 1
1378 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1379 offset.y /= std::fabs( offset.x );
1380 offset.x = ( offset.x > 0 ) ? +1 : -1;
1381 } else if( std::fabs( offset.y ) > 0.2 ) {
1382 offset.x /= std::fabs( offset.y );
1383 offset.y = offset.y > 0 ? +1 : -1;
1384 }
1385 offset.x *= rel_offset;
1386 offset.y *= rel_offset;
1387 offset.x *= max_offset.x;
1388 offset.y *= max_offset.y;
1389 // [ ----@---- ] sight=6
1390 // [ --@------ ] offset=2
1391 // [ -@------# ] offset=3
1392 // can see sights square in every direction, total visible area is
1393 // (2*sight+1)x(2*sight+1), but the window is only
1394 // getmaxx(w_terrain) x getmaxy(w_terrain)
1395 // The area outside of the window is maxoff (sight-getmax/2).
1396 // If that value is <= 0, the whole visible area fits the window.
1397 // don't apply the view offset at all.
1398 // If the offset is > maxoff, only apply at most maxoff, everything
1399 // above leads to invisible area in front of the car.
1400 // It will display (getmax/2+offset) squares in one direction and
1401 // (getmax/2-offset) in the opposite direction (centered on the PC).
1402 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1403 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1404 if( maxoff.x <= 0 ) {
1405 offset.x = 0;
1406 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1407 offset.x = maxoff.x;
1408 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1409 offset.x = -maxoff.x;
1410 }
1411 if( maxoff.y <= 0 ) {
1412 offset.y = 0;
1413 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1414 offset.y = maxoff.y;
1415 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1416 offset.y = -maxoff.y;
1417 }
1418
1419 // Turn the offset into a vector that increments the offset toward the desired position
1420 // instead of setting it there instantly, should smooth out jerkiness.
1421 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1422
1423 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1424 ( offset_difference.y < 0 ) ? -1 : 1 );
1425 // Shift the current offset in the direction of the calculated offset by one tile
1426 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1427 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1428 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1429 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1430 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1431
1432 set_driving_view_offset( point( offset.x, offset.y ) );
1433}
int posz() const override
Definition: character.h:785
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:719
point driving_view_offset
Definition: game.h:1018
catacurses::window w_terrain
Definition: game.h:1008
void set_driving_view_offset(const point &p)
Definition: game.cpp:1692
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3688
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1999
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1918
int cruise_velocity
Definition: vehicle.h:1920
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1317
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1793 of file game.cpp.

1794{
1796 if( u.has_distant_destination() ) {
1797 if( cancel_auto_move( u, text ) ) {
1798 return true;
1799 } else {
1801 return false;
1802 }
1803 }
1805 return false;
1806 }
1807 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1808 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1810
1811 const auto &action = query_popup()
1812 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1813 .message( force_uc ?
1814 pgettext( "cancel_activity_or_ignore_query",
1815 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1816 pgettext( "cancel_activity_or_ignore_query",
1817 "<color_light_red>%s %s</color>" ),
1818 text, u.activity.get_stop_phrase() )
1819 .option( "YES", allow_key )
1820 .option( "NO", allow_key )
1821 .option( "IGNORE", allow_key )
1822 .query()
1823 .action;
1824
1825 if( action == "YES" ) {
1827 return true;
1828 }
1829 if( action == "IGNORE" ) {
1831 for( auto &activity : u.backlog ) {
1832 activity.ignore_distraction( type );
1833 }
1834 }
1835
1838
1839 return false;
1840}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9230
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1517
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1780
void redraw()
Definition: ui_manager.cpp:285
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1842 of file game.cpp.

1843{
1845 if( u.has_distant_destination() ) {
1846 if( cancel_auto_move( u, text ) ) {
1847 return true;
1848 } else {
1850 return false;
1851 }
1852 }
1853 if( !u.activity ) {
1854 return false;
1855 }
1856 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1860 return true;
1861 }
1862 return false;
1863}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9262

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1766 of file game.cpp.

1768{
1769 //spawn the corpse, rotten by a part of the duration
1771 catch_duration ) ) );
1772 if( u.sees( pos ) ) {
1773 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1774 }
1775 //quietly kill the caught
1776 fish->no_corpse_quiet = true;
1777 fish->die( p );
1778}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:506
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4214
bool no_corpse_quiet
Definition: monster.h:484
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2247
const mtype * type
Definition: monster.h:480
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:3973
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 394 of file npctalk.cpp.

395{
396 int volume = g->u.get_shout_volume();
397
398 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
399 // TODO: Get rid of the z-level check when z-level vision gets "better"
400 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
401 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
402 } );
403 const int available_count = available.size();
404 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
405 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
406 } );
407 const int follower_count = followers.size();
408 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
409 return guy.mission == NPC_MISSION_GUARD_ALLY &&
410 guy.companion_mission_role_id != "FACTION_CAMP" &&
411 guy.can_hear( u.pos(), volume );
412 } );
413 const int guard_count = guards.size();
414
415 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
416 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
417 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
418 return;
419 }
420 std::vector<vehicle *> animal_vehicles;
421 std::vector<vehicle *> following_vehicles;
422 std::vector<vehicle *> magic_vehicles;
423 std::vector<vehicle *> magic_following_vehicles;
424 for( auto &veh : g->m.get_vehicles() ) {
425 auto &v = veh.v;
426 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
427 animal_vehicles.push_back( v );
428 if( v->is_following ) {
429 following_vehicles.push_back( v );
430 }
431 }
432 if( v->magic ) {
433 for( const vpart_reference &vp : v->get_all_parts() ) {
434 const vpart_info &vpi = vp.info();
435 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
436 magic_vehicles.push_back( v );
437 if( v->is_following ) {
438 magic_following_vehicles.push_back( v );
439 }
440 break;
441 }
442 }
443 }
444 }
445
446 uilist nmenu;
447 nmenu.text = std::string( _( "What do you want to do?" ) );
448
449 if( !available.empty() ) {
450 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
451 string_format( _( "Talk to %s" ), available.front()->name ) :
452 _( "Talk to…" )
453 );
454 }
455 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
456 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
457 if( !animal_vehicles.empty() ) {
459 _( "Whistle at your animals pulling vehicles to follow you." ) );
460 }
461 if( !magic_vehicles.empty() ) {
463 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
464 }
465 if( !magic_following_vehicles.empty() ) {
467 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
468 }
469 if( !following_vehicles.empty() ) {
471 _( "Whistle at your animals pulling vehicles to stop following you." ) );
472 }
473 if( !guards.empty() ) {
474 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
475 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
476 _( "Tell someone to follow…" )
477 );
478 }
479 if( !followers.empty() ) {
480 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
481 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
482 _( "Tell someone to guard…" )
483 );
484 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
485 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
486 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
487 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
488 _( "Tell everyone on your team to prepare for danger" ) );
489 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
490 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
491 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
492 }
493 std::string message;
494 std::string yell_msg;
495 bool is_order = true;
496 nmenu.query();
497
498 if( nmenu.ret < 0 ) {
499 return;
500 }
501
502 switch( nmenu.ret ) {
503 case NPC_CHAT_TALK: {
504 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
505 if( npcselect < 0 ) {
506 return;
507 }
508 available[npcselect]->talk_to_u();
509 break;
510 }
511 case NPC_CHAT_YELL:
512 is_order = false;
513 message = _( "loudly." );
514 break;
515 case NPC_CHAT_SENTENCE: {
516 std::string popupdesc = _( "Enter a sentence to yell" );
518 popup.title( _( "Yell a sentence" ) )
519 .width( 64 )
520 .description( popupdesc )
521 .identifier( "sentence" )
522 .max_length( 128 )
523 .query();
524 yell_msg = popup.text();
525 is_order = false;
526 break;
527 }
528 case NPC_CHAT_GUARD: {
529 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
530 if( npcselect < 0 ) {
531 return;
532 }
533 if( npcselect == follower_count ) {
534 for( npc *them : followers ) {
536 }
537 yell_msg = _( "Everyone guard here!" );
538 } else {
539 talk_function::assign_guard( *followers[npcselect] );
540 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
541 }
542 break;
543 }
544 case NPC_CHAT_FOLLOW: {
545 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
546 if( npcselect < 0 ) {
547 return;
548 }
549 if( npcselect == guard_count ) {
550 for( npc *them : guards ) {
552 }
553 yell_msg = _( "Everyone follow me!" );
554 } else {
555 talk_function::stop_guard( *guards[npcselect] );
556 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
557 }
558 break;
559 }
560 case NPC_CHAT_AWAKE:
561 for( npc *them : followers ) {
562 talk_function::wake_up( *them );
563 }
564 yell_msg = _( "Stay awake!" );
565 break;
566 case NPC_CHAT_MOUNT:
567 for( npc *them : followers ) {
568 if( them->has_effect( effect_riding ) ) {
569 continue;
570 }
572 }
573 yell_msg = _( "Mount up!" );
574 break;
576 for( npc *them : followers ) {
577 if( them->has_effect( effect_riding ) ) {
578 them->npc_dismount();
579 }
580 }
581 yell_msg = _( "Dismount!" );
582 break;
583 case NPC_CHAT_DANGER:
584 for( npc *them : followers ) {
585 them->rules.set_danger_overrides();
586 }
587 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
588 "and don't open any doors." );
589 break;
591 for( npc *p : followers ) {
593 }
594 yell_msg = _( "As you were." );
595 break;
596 case NPC_CHAT_ORDERS:
597 npc_temp_orders_menu( followers );
598 break;
601 break;
604 break;
607 break;
610 break;
611 default:
612 return;
613 }
614
615 if( !yell_msg.empty() ) {
616 message = string_format( "\"%s\"", yell_msg );
617 }
618 if( !message.empty() ) {
619 add_msg( _( "You yell %s" ), message );
620 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
621 }
622
623 u.moves -= 100;
624}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:546
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7727
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1987
bool is_following() const
Definition: npc.cpp:2018
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:403
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4126
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:220
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:377
static void tell_veh_stop_following()
Definition: npctalk.cpp:340
static void assign_veh_to_follow()
Definition: npctalk.cpp:351
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:252
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:214
@ NPC_CHAT_YELL
Definition: npctalk.cpp:195
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:198
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:197
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:201
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:203
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:196
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:210
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:202
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:199
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:212
@ NPC_CHAT_TALK
Definition: npctalk.cpp:194
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:213
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:361
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 346 of file game.cpp.

347{
348 auto &tree = world_generator->get_mod_manager().get_tree();
349
350 // deduplicated list of mods to check
351 std::set<mod_id> check( opts.begin(), opts.end() );
352
353 // if no specific mods specified check all non-obsolete mods
354 if( check.empty() ) {
355 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
356 if( !e->obsolete ) {
357 check.emplace( e );
358 }
359 }
360 }
361
362 if( check.empty() ) {
363 world_generator->set_active_world( nullptr );
364 world_generator->init();
365 const std::vector<mod_id> mods_empty;
366 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
367 world_generator->set_active_world( test_world );
368
369 // if no loadable mods then test core data only
370 try {
373 } catch( const std::exception &err ) {
374 std::cerr << "Error loading data from json: " << err.what() << std::endl;
375 }
376
377 std::string world_name = world_generator->active_world->world_name;
378 world_generator->delete_world( world_name, true );
379
382 }
383
384 for( const auto &e : check ) {
385 world_generator->set_active_world( nullptr );
386 world_generator->init();
387 const std::vector<mod_id> mods_empty;
388 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
389 if( !test_world ) {
390 std::cerr << "Failed to generate test world." << std::endl;
391 return false;
392 }
393 world_generator->set_active_world( test_world );
394
395 if( !e.is_valid() ) {
396 std::cerr << "Unknown mod: " << e.str() << std::endl;
397 return false;
398 }
399
400 const MOD_INFORMATION &mod = *e;
401
402 if( !tree.is_available( mod.ident ) ) {
403 std::cerr << "Missing dependencies: " << mod.name() << "\n"
404 << tree.get_node( mod.ident )->s_errors() << std::endl;
405 return false;
406 }
407
408 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
409
410 try {
412
413 // Load any dependencies
414 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
415 load_data_from_dir( dep->path, dep->ident.str(), ui );
416 }
417
418 // Load mod itself
419 load_data_from_dir( mod.path, mod.ident.str(), ui );
421 } catch( const std::exception &err ) {
422 std::cerr << "Error loading data: " << err.what() << std::endl;
423 }
424
425 std::string world_name = world_generator->active_world->world_name;
426 world_generator->delete_world( world_name, true );
427
430 }
431 return true;
432}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:627
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:112
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:448
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:439
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6069 of file game.cpp.

6070{
6071 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6072}
static zone_manager & get_manager()
Definition: clzones.cpp:125
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 8595 of file game.cpp.

8596{
8597 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
8598 // Already warned player since safe_mode_warning_logged is set.
8599 return false;
8600 }
8601
8602 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
8603 if( !msg_ignore.empty() ) {
8604 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
8605 // Operate on a wide-char basis to prevent corrupted multi-byte string
8606 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
8607 msg_ignore = wstr_to_utf8( msg_ignore_wide );
8608 }
8609
8611 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
8612 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
8614 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
8615 } else {
8617 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
8618 }
8620 return false;
8621 }
8622 if( safe_mode != SAFE_MODE_STOP ) {
8623 return true;
8624 }
8625 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
8626 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
8627 return true;
8628 }
8629 // Monsters around and we don't want to run
8630 std::string spotted_creature_name;
8631 const monster_visible_info &mon_visible = u.get_mon_visible();
8632 const auto &new_seen_mon = mon_visible.new_seen_mon;
8633
8634 if( new_seen_mon.empty() ) {
8635 // naming consistent with code in game::mon_info
8636 spotted_creature_name = _( "a survivor" );
8638 } else {
8639 spotted_creature_name = new_seen_mon.back()->name();
8640 get_safemode().lastmon_whitelist = spotted_creature_name;
8641 }
8642
8643 std::string whitelist;
8644 if( !get_safemode().empty() ) {
8645 whitelist = string_format( _( " or %s to whitelist the monster" ),
8647 }
8648
8649 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
8651 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
8652 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
8654 return false;
8655}
std::string press_x(action_id act)
Definition: action.cpp:452
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1179
int get_int_base() const override
Definition: avatar.cpp:1001
monster_visible_info & get_mon_visible()
Definition: avatar.h:211
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:281
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:286
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:40

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6064 of file game.cpp.

6065{
6066 return zone_manager::get_manager().has( type, m.getabs( where ) );
6067}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1031 of file game.cpp.

1032{
1033 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1034 // Put (non-hallucinations) into the overmap so they are not lost.
1035 for( monster &critter : all_monsters() ) {
1036 despawn_monster( critter );
1037 }
1038 // Reset NPC factions and disposition
1040 // Save the factions', missions and set the NPC's overmap coordinates
1041 // Npcs are saved in the overmap.
1042 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1043 // save artifacts.
1045
1046 // and the overmap, and the local map.
1047 save_maps(); //Omap also contains the npcs who need to be saved.
1048 }
1049
1050 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1051 std::vector<std::string> vRip;
1052
1053 int iMaxWidth = 0;
1054 int iNameLine = 0;
1055 int iInfoLine = 0;
1056
1059 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1060 vRip.emplace_back( " _______ ___" );
1061 vRip.emplace_back( " < `/ |" );
1062 vRip.emplace_back( " > _ _ (" );
1063 vRip.emplace_back( " | |_) | |_) |" );
1064 vRip.emplace_back( " | | \\ | | |" );
1065 vRip.emplace_back( " ______.__%_| |_________ __" );
1066 vRip.emplace_back( " _/ \\| |" );
1067 iNameLine = vRip.size();
1068 vRip.emplace_back( "| <" );
1069 vRip.emplace_back( "| |" );
1070 iMaxWidth = utf8_width( vRip.back() );
1071 vRip.emplace_back( "| |" );
1072 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1073 vRip.emplace_back( " | |" );
1074 iInfoLine = vRip.size();
1075 vRip.emplace_back( " | |" );
1076 vRip.emplace_back( " | <" );
1077 vRip.emplace_back( " | |" );
1078 vRip.emplace_back( " | _ |" );
1079 vRip.emplace_back( " |__/ |" );
1080 vRip.emplace_back( " % / `--. |%" );
1081 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1082 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1083 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1084 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1085
1086 } else {
1087 vRip.emplace_back( " _______ ___" );
1088 vRip.emplace_back( " | \\/ |" );
1089 vRip.emplace_back( " | |" );
1090 vRip.emplace_back( " | |" );
1091 iInfoLine = vRip.size();
1092 vRip.emplace_back( " | |" );
1093 vRip.emplace_back( " | |" );
1094 vRip.emplace_back( " | |" );
1095 vRip.emplace_back( " | |" );
1096 vRip.emplace_back( " | <" );
1097 vRip.emplace_back( " | _ |" );
1098 vRip.emplace_back( " |__/ |" );
1099 vRip.emplace_back( " ______.__%_| |__________ _" );
1100 vRip.emplace_back( " _/ \\| \\" );
1101 iNameLine = vRip.size();
1102 vRip.emplace_back( "| <" );
1103 vRip.emplace_back( "| |" );
1104 iMaxWidth = utf8_width( vRip.back() );
1105 vRip.emplace_back( "| |" );
1106 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1107 vRip.emplace_back( " % / `_-. _ |%" );
1108 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1109 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1110 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1111 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1112 }
1113 } else {
1114 vRip.emplace_back( R"( _________ ____ )" );
1115 vRip.emplace_back( R"( _/ `/ \_ )" );
1116 vRip.emplace_back( R"( _/ _ _ \_. )" );
1117 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1118 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1119 vRip.emplace_back( R"( _/ \_ )" );
1120 vRip.emplace_back( R"(| |)" );
1121 iNameLine = vRip.size();
1122 vRip.emplace_back( R"( ) < )" );
1123 vRip.emplace_back( R"(| |)" );
1124 vRip.emplace_back( R"(| |)" );
1125 vRip.emplace_back( R"(| _ |)" );
1126 vRip.emplace_back( R"(|__/ |)" );
1127 iMaxWidth = utf8_width( vRip.back() );
1128 vRip.emplace_back( R"( / `--. |)" );
1129 vRip.emplace_back( R"(| ( )" );
1130 iInfoLine = vRip.size();
1131 vRip.emplace_back( R"(| |)" );
1132 vRip.emplace_back( R"(| |)" );
1133 vRip.emplace_back( R"(| % . |)" );
1134 vRip.emplace_back( R"(| @` %% |)" );
1135 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1136 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1137 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1138 }
1139
1140 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1141 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1142
1144 point( iOffsetX, iOffsetY ) );
1145 draw_border( w_rip );
1146
1147 sfx::do_player_death_hurt( g->u, true );
1152
1153 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1154 size_t iX = 0;
1155 const char *str = vRip[iY].data();
1156 for( int slen = vRip[iY].size(); slen > 0; ) {
1157 const uint32_t cTemp = UTF8_getch( &str, &slen );
1158 if( cTemp != U' ' ) {
1159 nc_color ncColor = c_light_gray;
1160
1161 if( cTemp == U'%' ) {
1162 ncColor = c_green;
1163
1164 } else if( cTemp == U'_' || cTemp == U'|' ) {
1165 ncColor = c_white;
1166
1167 } else if( cTemp == U'@' ) {
1168 ncColor = c_brown;
1169
1170 } else if( cTemp == U'*' ) {
1171 ncColor = c_red;
1172 }
1173
1174 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1175 cTemp );
1176 }
1177 iX += mk_wcwidth( cTemp );
1178 }
1179 }
1180
1181 std::string sTemp;
1182
1183 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1184
1186 const int minutes = to_minutes<int>( survived ) % 60;
1187 const int hours = to_hours<int>( survived ) % 24;
1188 const int days = to_days<int>( survived );
1189
1190 if( days > 0 ) {
1191 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1192 } else if( hours > 0 ) {
1193 sTemp = string_format( "%dh %dm", hours, minutes );
1194 } else {
1195 sTemp = string_format( "%dm", minutes );
1196 }
1197
1198 center_print( w_rip, iInfoLine++, c_white, sTemp );
1199
1200 const int iTotalKills = get_kill_tracker().monster_kill_count();
1201
1202 sTemp = _( "Kills:" );
1203 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1204 ( sTemp + " " ) );
1205 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1206
1207 sTemp = _( "In memory of:" );
1208 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1210 sTemp );
1211
1212 sTemp = u.name;
1213 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1214 sTemp );
1215
1216 sTemp = _( "Last Words:" );
1217 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1219 sTemp );
1220
1221 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1222 std::string sLastWords = string_input_popup()
1223 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1224 .max_length( iMaxWidth - 4 - 1 )
1225 .query_string();
1226 death_screen();
1227 const bool is_suicide = uquit == QUIT_SUICIDE;
1228 events().send<event_type::game_over>( is_suicide, sLastWords );
1229 // Struck the save_player_data here to forestall Weirdness
1230 std::string char_filename = generate_memorial_filename( u.name );
1231 move_save_to_graveyard( char_filename );
1232 write_memorial_file( char_filename, sLastWords );
1233 memorial().clear();
1234 std::vector<std::string> characters = list_active_characters();
1235 // remove current player from the active characters list, as they are dead
1236 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1237 characters.end(), u.name );
1238 if( curchar != characters.end() ) {
1239 characters.erase( curchar );
1240 }
1241
1242 if( characters.empty() ) {
1243 bool queryDelete = false;
1244 bool queryReset = false;
1245
1246 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1247 bool decided = false;
1248 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1249 "will not all reset when starting a new character in an "
1250 "already-played world. This can lead to some strange "
1251 "behavior.\n\n"
1252 "Are you sure you wish to keep this world?"
1253 );
1254
1255 while( !decided ) {
1256 uilist smenu;
1257 smenu.allow_cancel = false;
1258 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1259 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1260 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1261 smenu.query();
1262
1263 switch( smenu.ret ) {
1264 case 0:
1265 queryReset = true;
1266 decided = true;
1267 break;
1268 case 1:
1269 queryDelete = true;
1270 decided = true;
1271 break;
1272 case 2:
1273 decided = query_yn( buffer );
1274 break;
1275 }
1276 }
1277 }
1278
1279 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1280 world_generator->delete_world( world_generator->active_world->world_name, true );
1281
1282 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1283 world_generator->delete_world( world_generator->active_world->world_name, false );
1284 }
1285 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1286 std::string tmpmessage;
1287 for( auto &character : characters ) {
1288 tmpmessage += "\n ";
1289 tmpmessage += character;
1290 }
1291 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1292 }
1293 if( gamemode ) {
1294 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1295 }
1296 }
1297
1298 //Reset any offset due to driving
1300
1301 //clear all sound channels
1307
1308 MAPBUFFER.reset();
1310
1311#if defined(__ANDROID__)
1312 quick_shortcuts_map.clear();
1313#endif
1314 return true;
1315}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1504
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2547
bool save_maps()
Definition: game.cpp:2811
std::unique_ptr< special_game > gamemode
Definition: game.h:1076
void death_screen()
Definition: game.cpp:2497
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12014
bool save_factions_missions_npcs()
Definition: game.cpp:2797
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11039
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:969
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:2910
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:2895
bool save_artifacts()
Definition: game.cpp:2805
memorial_logger & memorial()
Definition: game.cpp:2860
void reset_npc_dispositions()
Definition: game.cpp:2769
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1004
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4136 of file game.cpp.

4137{
4138 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4139 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4140 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4141
4142 bool npc_is_dead = false;
4143 // can't use all_npcs as that does not include dead ones
4144 for( const auto &n : active_npc ) {
4145 if( n->is_dead() ) {
4146 n->die( nullptr ); // make sure this has been called to create corpses etc.
4147 npc_is_dead = true;
4148 }
4149 }
4150
4151 if( monster_is_dead ) {
4152 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4153 critter_tracker->remove_dead();
4154 }
4155
4156 if( npc_is_dead ) {
4157 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4158 if( ( *it )->is_dead() ) {
4159 remove_npc_follower( ( *it )->getID() );
4160 overmap_buffer.remove_npc( ( *it )->getID() );
4161 it = active_npc.erase( it );
4162 } else {
4163 it++;
4164 }
4165 }
4166 }
4167
4168 critter_died = false;
4169}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1967
pimpl< Creature_tracker > critter_tracker
Definition: game.h:994
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1058
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1070
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 4810 of file game.cpp.

4811{
4812 critter_tracker->clear();
4813}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5224 of file game.cpp.

5225{
5226 static const itype_id fuel_type_animal( "animal" );
5227 int veh_part = -1;
5228 vehicle *veh = remoteveh();
5229 if( veh == nullptr ) {
5230 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5231 veh = &vp->vehicle();
5232 veh_part = vp->part_index();
5233 }
5234 }
5235 if( veh != nullptr && veh->player_in_control( u ) &&
5236 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5237 veh->use_controls( u.pos() );
5238 } else if( veh && veh->player_in_control( u ) &&
5239 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5240 u.controlling_vehicle = false;
5241 add_msg( m_info, _( "You let go of the reins." ) );
5242 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5243 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5244 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5245 u.in_vehicle ) {
5246 if( u.has_trait( trait_WAYFARER ) ) {
5247 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5248 return;
5249 }
5250 if( !veh->interact_vehicle_locked() ) {
5251 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5252 return;
5253 }
5254 if( veh->engine_on ) {
5255 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5256 return;
5257 }
5258 u.controlling_vehicle = true;
5259 add_msg( _( "You take control of the %s." ), veh->name );
5260 } else {
5261 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5262 return;
5263 }
5264 veh->start_engines( true );
5265 }
5266 } else { // Start looking for nearby vehicle controls.
5267 int num_valid_controls = 0;
5268 cata::optional<tripoint> vehicle_position;
5269 cata::optional<vpart_reference> vehicle_controls;
5270 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5271 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5272 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5273 if( controls ) {
5274 num_valid_controls++;
5275 vehicle_position = elem;
5276 vehicle_controls = controls;
5277 }
5278 }
5279 }
5280 if( num_valid_controls < 1 ) {
5281 add_msg( _( "No vehicle controls found." ) );
5282 return;
5283 } else if( num_valid_controls > 1 ) {
5284 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5285 if( !vehicle_position ) {
5286 return;
5287 }
5288 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5289 if( vp ) {
5290 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5291 if( !vehicle_controls ) {
5292 add_msg( _( "The vehicle doesn't have controls there." ) );
5293 return;
5294 }
5295 } else {
5296 add_msg( _( "No vehicle there." ) );
5297 return;
5298 }
5299 }
5300 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5301 if( vehicle_controls ) {
5302 veh = &vehicle_controls->vehicle();
5303 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5304 return;
5305 }
5306 veh->use_controls( *vehicle_position );
5307 //May be folded up (destroyed), so need to re-get it
5308 veh = g->remoteveh();
5309 }
5310 }
5311 if( veh ) {
5312 // If we reached here, we gained control of a vehicle.
5313 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5314 for( const tripoint &target : veh->get_points() ) {
5315 u.clear_memorized_tile( m.getabs( target ) );
5316 }
5317 veh->is_following = false;
5318 veh->is_patrolling = false;
5319 veh->autopilot_on = false;
5320 veh->is_autodriving = false;
5321 }
5322}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1019
bool in_vehicle
Definition: character.h:1511
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:165
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2333
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8559
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1004
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:90
bool engine_on
Definition: vehicle.h:1989
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6758
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4377
std::string name
Definition: vehicle.h:1849
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1997
bool is_autodriving
Definition: vehicle.h:1982
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3047 of file game.cpp.

3048{
3050 if( !ui ) {
3051 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3052 ui->on_redraw( []( const ui_adaptor & ) {
3053 g->draw();
3054 } );
3055 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3056 // remove some space for the sidebar, this is the maximal space
3057 // (using standard font) that the terrain window can have
3058 const int sidebar_left = panel_manager::get_manager().get_width_left();
3059 const int sidebar_right = panel_manager::get_manager().get_width_right();
3060
3062 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3065
3066 /**
3067 * In tiles mode w_terrain can have a different font (with a different
3068 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3069 * might have a different dimension then the normal font used everywhere else.
3070 *
3071 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3072 * be displayed in w_terrain (using it's specific tile dimension), not
3073 * including partially drawn squares at the right/bottom. You should
3074 * use it whenever you want to draw specific squares in that window or to
3075 * determine whether a specific square is draw on screen (or outside the screen
3076 * and needs scrolling).
3077 *
3078 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3079 * w_terrain in the standard font dimension (the font that everything else uses).
3080 * You usually don't have to use it, expect for positioning of windows,
3081 * because the window positions use the standard font dimension.
3082 *
3083 * The code here calculates size available for w_terrain, caps it at
3084 * max_view_size (the maximal view range than any character can have at
3085 * any time).
3086 * It is stored in TERRAIN_WINDOW_*.
3087 */
3089
3090 // Position of the player in the terrain window, it is always in the center
3093
3095 point( sidebar_left, 0 ) );
3096
3097 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3099
3100 // need to init in order to avoid crash. gets updated by the panel code.
3102
3103 ui.position_from_window( catacurses::stdscr );
3104 } );
3105 ui->mark_resize();
3106 }
3107 return ui;
3108}
catacurses::window w_pixel_minimap
Definition: game.h:1012
catacurses::window w_minimap_ptr
Definition: game.h:1049
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1095
catacurses::window w_minimap
Definition: game.h:1011
catacurses::window w_terrain_ptr
Definition: game.h:1048
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2294
int get_width_left()
Definition: panels.cpp:2302
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 974 of file game.cpp.

975{
976 if( !get_option<bool>( "STATIC_NPC" ) ||
977 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
978 return; //Do not generate a starting npc.
979 }
980
981 //We don't want more than one starting npc per starting location
982 const int radius = 1;
983 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
984 return; //There is already an NPC in this starting location
985 }
986
987 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
988 tmp->normalize();
989 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
990 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
992 tmp->form_opinion( u );
993 tmp->set_attitude( NPCATT_NULL );
994 //This sets the NPC mission. This NPC remains in the starting location.
995 tmp->mission = NPC_MISSION_SHELTER;
996 tmp->chatbin.first_topic = "TALK_SHELTER";
997 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
998 tmp->set_fac( faction_id( "no_faction" ) );
999 //One random starting NPC mission
1000 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
1001 tmp->getID() ) );
1002}
int get_levy() const
Definition: game.cpp:11904
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:11899
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4615 of file game.cpp.

4616{
4617 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4618 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4619 return nullptr;
4620 }
4621 // if we wanted to check for an NPC / player / avatar,
4622 // there is sometimes a monster AND an NPC/player there at the same time.
4623 // because the NPC/player etc may be riding that monster.
4624 // so only return the monster if we were actually looking for a monster.
4625 // otherwise, keep looking for the rider.
4626 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4627 // which is ok for the occasions where that happens.
4628 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4629 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4630 std::is_same<T, const Creature>::value ) ) {
4631 return dynamic_cast<T *>( mon_ptr.get() );
4632 }
4633 }
4634 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4635 if( p == u.pos() ) {
4636 return dynamic_cast<T *>( &u );
4637 }
4638 }
4639 for( auto &cur_npc : active_npc ) {
4640 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4641 return dynamic_cast<T *>( cur_npc.get() );
4642 }
4643 }
4644 return nullptr;
4645}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4648 of file game.cpp.

4649{
4650 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4651}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4694 of file game.cpp.

4695{
4696 if( id == u.getID() ) {
4697 // player is always alive, therefore no is-dead check
4698 return dynamic_cast<T *>( &u );
4699 }
4700 return find_npc( id );
4701}
character_id getID() const
Definition: character.cpp:477
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1956

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2497 of file game.cpp.

2498{
2499 gamemode->game_over();
2503 follower_ids.clear();
2505}
stats_tracker & stats()
Definition: game.cpp:2855
void disp_NPC_epilogues()
Definition: game.cpp:2934
void display_faction_epilogues()
Definition: game.cpp:2951
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11039 of file game.cpp.

11040{
11041 if( !critter.is_hallucination() ) {
11042 // hallucinations aren't stored, they come and go as they like,
11044 }
11045
11046 critter.on_unload();
11047 remove_zombie( critter );
11048 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11049 critter.set_hp( 0 );
11050}
void remove_zombie(const monster &critter)
Definition: game.cpp:4805
bool is_hallucination() const override
Definition: monster.cpp:2652
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:2984
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1635
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 8663 of file game.cpp.

8664{
8665 monster *const mon_ptr = critter_at<monster>( p );
8666 if( !mon_ptr ) {
8667 return false;
8668 }
8669 monster &critter = *mon_ptr;
8670 if( critter.friendly == 0 || critter.has_flag( MF_RIDEABLE_MECH ) ||
8671 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
8672 // Can only disable / reprogram friendly monsters
8673 return false;
8674 }
8675 const auto mid = critter.type->id;
8676 const auto mon_item_id = critter.type->revert_to_itype;
8677 if( !mon_item_id.is_empty() &&
8678 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
8679
8680 u.moves -= 100;
8681 m.add_item_or_charges( p, critter.to_item() );
8682 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
8683 for( auto &ammodef : critter.ammo ) {
8684 if( ammodef.second > 0 ) {
8685 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
8686 }
8687 }
8688 }
8689 remove_zombie( critter );
8690 return true;
8691 }
8692 // Manhacks are special, they have their own menu here.
8693 if( mid == mon_manhack ) {
8694 int choice = UILIST_CANCEL;
8695 if( critter.has_effect( effect_docile ) ) {
8696 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
8697 } else {
8698 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
8699 }
8700 switch( choice ) {
8701 case 0:
8702 if( critter.has_effect( effect_docile ) ) {
8703 critter.remove_effect( effect_docile );
8704 if( one_in( 3 ) ) {
8705 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
8706 critter.name() );
8707 }
8708 } else {
8709 critter.add_effect( effect_docile, 1_turns, num_bp );
8710 if( one_in( 3 ) ) {
8711 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
8712 critter.name() );
8713 }
8714 }
8715 u.moves -= 100;
8716 return true;
8717 default:
8718 break;
8719 }
8720 }
8721 return false;
8722}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1136
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4173
bool has_flag(m_flag f) const override
Definition: monster.cpp:869
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2792
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1811
int friendly
Definition: monster.h:473
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:492
std::map< itype_id, int > ammo
Definition: monster.h:514
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:361
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 2934 of file game.cpp.

2935{
2936 // TODO: This search needs to be expanded to all NPCs
2937 for( auto elem : follower_ids ) {
2939 if( !guy ) {
2940 continue;
2941 }
2942 const auto new_win = []() {
2944 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2945 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2946 };
2947 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
2948 }
2949}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 2985 of file game.cpp.

2986{
2987 const tripoint_abs_omt ppos = u.global_omt_location();
2988 const tripoint &lpos = u.pos();
2989 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
2990 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
2991
2993 ui_adaptor ui;
2994 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
2997 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
2998 ui.position_from_window( w );
2999 } );
3000 ui.mark_resize();
3001 ui.on_redraw( [&]( const ui_adaptor & ) {
3002 werase( w );
3003 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3004 // NOLINTNEXTLINE(cata-use-named-point-constants)
3005 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3006 size_t i;
3007 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3008 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3009 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3010 apos.to_string() );
3011 }
3012 for( const monster &m : all_monsters() ) {
3013 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3014 m.posx(), m.posy(), m.posz() );
3015 ++i;
3016 }
3017 wnoutrefresh( w );
3018 } );
3019
3020 input_context ctxt( "DISP_NPCS" );
3021 ctxt.register_action( "CONFIRM" );
3022 ctxt.register_action( "QUIT" );
3023 ctxt.register_action( "HELP_KEYBINDINGS" );
3024 bool stop = false;
3025 while( !stop ) {
3027 const std::string action = ctxt.handle_input();
3028 if( action == "CONFIRM" || action == "QUIT" ) {
3029 stop = true;
3030 }
3031 }
3032}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6335
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1320
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 2951 of file game.cpp.

2952{
2953 for( const auto &elem : faction_manager_ptr->all() ) {
2954 if( elem.second.known_by_u ) {
2955 const std::vector<std::string> epilogue = elem.second.epilogue();
2956 if( !epilogue.empty() ) {
2957 const auto new_win = []() {
2959 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2960 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2961 };
2962 scrollable_text( new_win, elem.second.name,
2963 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
2964 []( const std::string & lhs, const std::string & rhs ) -> std::string {
2965 return lhs + "\n" + rhs;
2966 } ) );
2967 }
2968 }
2969 }
2970}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:995

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11251 of file game.cpp.

11252{
11253 if( use_tiles ) {
11255 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11256 return;
11257 }
11258 uilist lighting_menu;
11259 std::vector<std::string> lighting_menu_strings{
11260 "Global lighting conditions"
11261 };
11262
11263 int count = 0;
11264 for( const auto &menu_str : lighting_menu_strings ) {
11265 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11266 }
11267
11268 lighting_menu.w_y_setup = 0;
11269 lighting_menu.query();
11270 if( ( lighting_menu.ret >= 0 ) &&
11271 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11272 g->displaying_lighting_condition = lighting_menu.ret;
11273 }
11274 }
11275}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11147
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11142 of file game.cpp.

11143{
11145}
cata::optional< action_id > displaying_overlays
Definition: game.h:940

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11277 of file game.cpp.

11278{
11279 if( use_tiles ) {
11281 }
11282}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11156 of file game.cpp.

11157{
11158 if( use_tiles ) {
11160 } else {
11161 int div;
11162 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11163 if( !got_value || div < 1 ) {
11164 add_msg( _( "Never mind." ) );
11165 return;
11166 }
11167 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11168 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11169 } );
11170 g->add_draw_callback( scent_cb );
11171
11174 }
11175}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:599
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11177 of file game.cpp.

11178{
11179 if( use_tiles ) {
11181 }
11182}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11147 of file game.cpp.

11148{
11149 if( display_overlay_state( action ) ) {
11150 displaying_overlays.reset();
11151 } else {
11153 }
11154}
bool display_overlay_state(action_id)
Definition: game.cpp:11142

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11284 of file game.cpp.

11285{
11286 if( use_tiles ) {
11288 }
11289}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11184 of file game.cpp.

11185{
11186 if( use_tiles ) {
11188 }
11189}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11191 of file game.cpp.

11192{
11193 if( use_tiles ) {
11196 std::vector< tripoint > locations;
11197 uilist creature_menu;
11198 int num_creatures = 0;
11199 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11200 locations.emplace_back( g->u.pos() ); // add player first.
11201 for( const Creature &critter : g->all_creatures() ) {
11202 if( critter.is_player() ) {
11203 continue;
11204 }
11205 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11206 locations.emplace_back( critter.pos() );
11207 }
11208
11209 pointmenu_cb callback( locations );
11210 creature_menu.callback = &callback;
11211 creature_menu.w_y_setup = 0;
11212 creature_menu.query();
11213 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11214 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11216 }
11217 } else {
11219 }
11220 }
11221}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:4795
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1031
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1437 of file game.cpp.

1438{
1439 if( is_game_over() ) {
1440 return cleanup_at_end();
1441 }
1442 // Actual stuff
1443 if( new_game ) {
1444 new_game = false;
1445 } else {
1446 gamemode->per_turn();
1447 calendar::turn += 1_turns;
1448 }
1449
1450 // starting a new turn, clear out temperature cache
1452 weather.clear_temp_cache();
1453
1454 if( npcs_dirty ) {
1455 load_npcs();
1456 }
1457
1460 // If controlling a vehicle that is owned by someone else
1462 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1463 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1464 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1465 }
1466 }
1467 // If riding a horse - chance to spook
1468 if( u.is_mounted() ) {
1470 }
1471 if( calendar::once_every( 1_days ) ) {
1473 }
1474
1475 // Move hordes every 2.5 min
1478 // Hordes that reached the reality bubble need to spawn,
1479 // make them spawn in invisible areas only.
1480 m.spawn_monsters( false );
1481 }
1482
1484
1485 u.update_body();
1486
1487 // Auto-save if autosave is enabled
1488 if( get_option<bool>( "AUTOSAVE" ) &&
1489 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1490 !u.is_dead_state() ) {
1491 autosave();
1492 }
1493
1494 weather.update_weather();
1496
1500 // Process NPC sound events before they move or they hear themselves talking
1501 for( npc &guy : all_npcs() ) {
1502 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1504 }
1505 }
1506
1507 // Process sound events into sound markers for display to the player.
1509
1510 if( u.is_deaf() ) {
1512 }
1513
1514 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1515 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1516 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1517 cleanup_dead();
1519 // Process any new sounds the player caused during their turn.
1520 for( npc &guy : all_npcs() ) {
1521 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1523 }
1524 }
1527 wait_popup.reset();
1529 }
1530
1531 if( queue_screenshot ) {
1535 queue_screenshot = false;
1536 }
1537
1538 if( handle_action() ) {
1540 u.action_taken();
1541 }
1542
1543 if( is_game_over() ) {
1544 return cleanup_at_end();
1545 }
1546
1547 if( uquit == QUIT_WATCH ) {
1548 break;
1549 }
1550 if( u.activity ) {
1552 }
1553 }
1554 // Reset displayed sound markers now that the turn is over.
1555 // We only want this to happen if the player had a chance to examine the sounds.
1557 }
1558 }
1559
1560 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1561 // Still have a view offset, but might not be driving anymore,
1562 // or the option has been deactivated,
1563 // might also happen when someone dives from a moving car.
1564 // or when using the handbrake.
1565 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1566 calc_driving_offset( veh );
1567 }
1568
1569 // No-scent debug mutation has to be processed here or else it takes time to start working
1570 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1571 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1574 }
1575 scent.update( u.pos(), m );
1576
1577 // We need floor cache before checking falling 'n stuff
1579
1582 m.vehmove();
1583 m.process_fields();
1584 m.process_items();
1587
1588 // Apply sounds from previous turn to monster and NPC AI.
1590 // Update vision caches for monsters. If this turns out to be expensive,
1591 // consider a stripped down cache just for monsters.
1592 m.build_map_cache( get_levz(), true );
1593 monmove();
1594 if( calendar::once_every( 5_minutes ) ) {
1596 }
1597 if( calendar::once_every( 10_seconds ) ) {
1598 for( const tripoint &elem : m.get_furn_field_locations() ) {
1599 const auto &furn = m.furn( elem ).obj();
1600 for( const emit_id &e : furn.emissions ) {
1601 m.emit_field( elem, e );
1602 }
1603 }
1604 }
1607 u.process_turn();
1608
1610 cleanup_dead();
1611
1612 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1615 }
1616
1617 if( get_levz() >= 0 && !u.is_underwater() ) {
1618 handle_weather_effects( weather.weather_id );
1619 }
1620
1621 const bool player_is_sleeping = u.has_effect( effect_sleep );
1622 bool wait_redraw = false;
1623 std::string wait_message;
1624 time_duration wait_refresh_rate;
1625 if( player_is_sleeping ) {
1626 wait_redraw = true;
1627 wait_message = _( "Wait till you wake up…" );
1628 wait_refresh_rate = 30_minutes;
1629 if( calendar::once_every( 1_hours ) ) {
1631 }
1632 } else if( u.has_destination() ) {
1633 wait_redraw = true;
1634 wait_message = _( "Travelling…" );
1635 wait_refresh_rate = 15_turns;
1636 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1637 wait_redraw = true;
1638 wait_message = *progress;
1639 if( u.activity.id() == ACT_AUTODRIVE ) {
1640 wait_refresh_rate = 1_turns;
1641 } else {
1642 wait_refresh_rate = 5_minutes;
1643 }
1644 }
1645 if( wait_redraw ) {
1647 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1648 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1650 }
1651
1652 // Avoid redrawing the main UI every time due to invalidation
1654 wait_popup = std::make_unique<static_popup>();
1655 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1659 }
1660 } else {
1661 // Nothing to wait for now
1662 wait_popup.reset();
1664 }
1665
1667 u.update_body_wetness( get_weather().get_precise() );
1668 u.apply_wetness_morale( weather.temperature );
1669
1670 if( calendar::once_every( 1_minutes ) ) {
1671 u.update_morale();
1672 }
1673
1674 if( calendar::once_every( 9_turns ) ) {
1676 }
1677
1678 if( !u.is_deaf() ) {
1680 }
1685
1686 // reset player noise
1687 u.volume = 0;
1688
1689 return false;
1690}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:8998
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:877
bool check_mount_is_spooked()
Definition: character.cpp:1102
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5182
bool is_mounted() const
Definition: character.cpp:1143
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8757
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9125
bool is_deaf() const
Definition: character.cpp:4486
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4664
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1887
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1805
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:11909
void overmap_npc_move()
Definition: game.cpp:4296
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12019
void monmove()
Definition: game.cpp:4171
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1754
void add_artifact_dreams()
Definition: game.cpp:11853
int moves_since_last_save
Definition: game.h:1061
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7187
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1335
bool cleanup_at_end()
Definition: game.cpp:1031
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1097
bool queue_screenshot
Definition: game.h:1040
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11342
void process_activity()
Definition: game.cpp:1743
void update_stair_monsters()
Definition: game.cpp:10830
void process_voluntary_act_interrupt()
Definition: game.cpp:1704
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:899
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1068
void cleanup_dead()
Definition: game.cpp:4136
bool is_game_over()
Definition: game.cpp:2450
void perhaps_add_random_npc()
Definition: game.cpp:11077
void mon_info_update()
Definition: game.cpp:3941
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:8004
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2269
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1928
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7701
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7660
void vehmove()
Definition: map.cpp:410
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1563
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1343
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8170
void process_items()
Definition: map.cpp:4559
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:777
int volume
Definition: player.h:602
int scent
Definition: player.h:611
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1564
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:277
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:150
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1170
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3222 of file game.cpp.

3223{
3224 if( test_mode ) {
3225 return;
3226 }
3227
3228 //temporary fix for updating visibility for minimap
3229 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3232
3233 werase( w_terrain );
3234 draw_ter();
3235 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3236 shared_ptr_fast<draw_callback_t> cb = it->lock();
3237 if( cb ) {
3238 ( *cb )();
3239 ++it;
3240 } else {
3241 it = draw_callbacks.erase( it );
3242 }
3243 }
3245
3246 draw_panels( true );
3247}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1007
void draw_panels(bool force_draw=false)
Definition: game.cpp:3249
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3363
void update_visibility_cache(int zlev)
Definition: map.cpp:5586
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 955 of file animation.cpp.

956{
957}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 510 of file animation.cpp.

512{
513 draw_bullet_curses( m, t, bullet, &trajectory[i] );
514}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:451
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3345 of file game.cpp.

3346{
3347 draw_critter_internal( w_terrain, critter, center, false, m, u );
3348}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3312

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3350 of file game.cpp.

3351{
3352 draw_critter_internal( w_terrain, critter, center, true, m, u );
3353}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 716 of file animation.cpp.

717{
718 const tripoint rp = relative_view_pos( *this, p );
719 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
720}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:119
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 911 of file animation.cpp.

912{
913}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 872 of file animation.cpp.

873{
874}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 885 of file animation.cpp.

886{
887}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 729 of file animation.cpp.

730{
731 // Do nothing
732}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 573 of file animation.cpp.

574{
575 draw_hit_mon_curses( p, m, u, dead );
576}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:544

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 618 of file animation.cpp.

619{
620 draw_hit_player_curses( *this, p, dam );
621}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:581

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 925 of file animation.cpp.

927{
928}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 702 of file animation.cpp.

703{
704 draw_line_curses( *this, points );
705}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:682

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 669 of file animation.cpp.

671{
672 if( !u.sees( p ) ) {
673 return;
674 }
675
676 draw_line_curses( *this, center, points, noreveal );
677}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5732 of file game.cpp.

5733{
5734 if( !liveview.is_enabled() ) {
5735#if defined( TILES )
5736 if( is_draw_tiles_mode() ) {
5737 draw_cursor( lp );
5738 return;
5739 }
5740#endif
5741 const tripoint view_center = u.pos() + u.view_offset;
5742 visibility_type visibility = VIS_HIDDEN;
5743 const bool inbounds = m.inbounds( lp );
5744 if( inbounds ) {
5745 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5746 }
5747 if( visibility == VIS_CLEAR ) {
5748 const Creature *const creature = critter_at( lp, true );
5749 if( creature != nullptr && u.sees( *creature ) ) {
5750 creature->draw( w_terrain, view_center, true );
5751 } else {
5752 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5753 }
5754 } else {
5755 std::string visibility_indicator;
5756 nc_color visibility_indicator_color = c_white;
5757 switch( visibility ) {
5758 case VIS_CLEAR:
5759 // Already handled by the outer if statement
5760 break;
5761 case VIS_BOOMER:
5762 case VIS_BOOMER_DARK:
5763 visibility_indicator = '#';
5764 visibility_indicator_color = c_pink;
5765 break;
5766 case VIS_DARK:
5767 visibility_indicator = '#';
5768 visibility_indicator_color = c_dark_gray;
5769 break;
5770 case VIS_LIT:
5771 visibility_indicator = '#';
5772 visibility_indicator_color = c_light_gray;
5773 break;
5774 case VIS_HIDDEN:
5775 visibility_indicator = 'x';
5776 visibility_indicator_color = c_white;
5777 break;
5778 }
5779
5780 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
5781 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
5782 }
5783 }
5784}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:716
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4615
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7711
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5632
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:700
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5810
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:176

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3423 of file game.cpp.

3424{
3425
3426 // Draw the box
3427 werase( w_minimap );
3429
3430 const tripoint_abs_omt curs = u.global_omt_location();
3431 const point_abs_omt curs2( curs.xy() );
3433 bool drew_mission = targ == overmap::invalid_tripoint;
3434
3435 for( int i = -2; i <= 2; i++ ) {
3436 for( int j = -2; j <= 2; j++ ) {
3437 const point_abs_omt om( curs2 + point( i, j ) );
3438 nc_color ter_color;
3439 tripoint_abs_omt omp( om, get_levz() );
3440 std::string ter_sym;
3441 const bool seen = overmap_buffer.seen( omp );
3442 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3443 if( overmap_buffer.has_note( omp ) ) {
3444
3445 const std::string &note_text = overmap_buffer.note( omp );
3446
3447 ter_color = c_yellow;
3448 ter_sym = "N";
3449
3450 int symbolIndex = note_text.find( ':' );
3451 int colorIndex = note_text.find( ';' );
3452
3453 bool symbolFirst = symbolIndex < colorIndex;
3454
3455 if( colorIndex > -1 && symbolIndex > -1 ) {
3456 if( symbolFirst ) {
3457 if( colorIndex > 4 ) {
3458 colorIndex = -1;
3459 }
3460 if( symbolIndex > 1 ) {
3461 symbolIndex = -1;
3462 colorIndex = -1;
3463 }
3464 } else {
3465 if( symbolIndex > 4 ) {
3466 symbolIndex = -1;
3467 }
3468 if( colorIndex > 2 ) {
3469 colorIndex = -1;
3470 }
3471 }
3472 } else if( colorIndex > 2 ) {
3473 colorIndex = -1;
3474 } else if( symbolIndex > 1 ) {
3475 symbolIndex = -1;
3476 }
3477
3478 if( symbolIndex > -1 ) {
3479 int symbolStart = 0;
3480 if( colorIndex > -1 && !symbolFirst ) {
3481 symbolStart = colorIndex + 1;
3482 }
3483 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3484 }
3485
3486 if( colorIndex > -1 ) {
3487
3488 int colorStart = 0;
3489
3490 if( symbolIndex > -1 && symbolFirst ) {
3491 colorStart = symbolIndex + 1;
3492 }
3493
3494 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3495
3496 if( sym.length() == 2 ) {
3497 if( sym == "br" ) {
3498 ter_color = c_brown;
3499 } else if( sym == "lg" ) {
3500 ter_color = c_light_gray;
3501 } else if( sym == "dg" ) {
3502 ter_color = c_dark_gray;
3503 }
3504 } else {
3505 char colorID = sym.c_str()[0];
3506 if( colorID == 'r' ) {
3507 ter_color = c_light_red;
3508 } else if( colorID == 'R' ) {
3509 ter_color = c_red;
3510 } else if( colorID == 'g' ) {
3511 ter_color = c_light_green;
3512 } else if( colorID == 'G' ) {
3513 ter_color = c_green;
3514 } else if( colorID == 'b' ) {
3515 ter_color = c_light_blue;
3516 } else if( colorID == 'B' ) {
3517 ter_color = c_blue;
3518 } else if( colorID == 'W' ) {
3519 ter_color = c_white;
3520 } else if( colorID == 'C' ) {
3521 ter_color = c_cyan;
3522 } else if( colorID == 'c' ) {
3523 ter_color = c_light_cyan;
3524 } else if( colorID == 'P' ) {
3525 ter_color = c_pink;
3526 } else if( colorID == 'm' ) {
3527 ter_color = c_magenta;
3528 }
3529 }
3530 }
3531 } else if( !seen ) {
3532 ter_sym = " ";
3533 ter_color = c_black;
3534 } else if( vehicle_here ) {
3535 ter_color = c_cyan;
3536 ter_sym = "c";
3537 } else {
3538 const oter_id &cur_ter = overmap_buffer.ter( omp );
3539 ter_sym = cur_ter->get_symbol();
3540 if( overmap_buffer.is_explored( omp ) ) {
3541 ter_color = c_dark_gray;
3542 } else {
3543 ter_color = cur_ter->get_color();
3544 }
3545 }
3546 if( !drew_mission && targ.xy() == omp.xy() ) {
3547 // If there is a mission target, and it's not on the same
3548 // overmap terrain as the player character, mark it.
3549 // TODO: Inform player if the mission is above or below
3550 drew_mission = true;
3551 if( i != 0 || j != 0 ) {
3552 ter_color = red_background( ter_color );
3553 }
3554 }
3555 if( i == 0 && j == 0 ) {
3556 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3557 } else {
3558 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3559 }
3560 }
3561 }
3562
3563 // Print arrow to mission if we have one!
3564 if( !drew_mission ) {
3565 double slope = curs2.x() != targ.x() ?
3566 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3567
3568 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3569 if( targ.y() > curs2.y() ) {
3570 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3571 } else {
3572 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3573 }
3574 } else {
3575 int arrowx = -1;
3576 int arrowy = -1;
3577 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3578 arrowy = targ.y() > curs2.y() ? 6 : 0;
3579 arrowx =
3580 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3581 if( arrowx < 0 ) {
3582 arrowx = 0;
3583 }
3584 if( arrowx > 6 ) {
3585 arrowx = 6;
3586 }
3587 } else {
3588 arrowx = targ.x() > curs2.x() ? 6 : 0;
3589 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3590 if( arrowy < 0 ) {
3591 arrowy = 0;
3592 }
3593 if( arrowy > 6 ) {
3594 arrowy = 6;
3595 }
3596 }
3597 char glyph = '*';
3598 if( targ.z() > u.posz() ) {
3599 glyph = '^';
3600 } else if( targ.z() < u.posz() ) {
3601 glyph = 'v';
3602 }
3603
3604 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3605 }
3606 }
3607
3608 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3609 for( int i = -3; i <= 3; i++ ) {
3610 for( int j = -3; j <= 3; j++ ) {
3611 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3612 continue; // only do hordes on the border, skip inner map
3613 }
3614 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3616 if( overmap_buffer.seen( omp )
3617 && g->u.overmap_los( omp, sight_points ) ) {
3618 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3619 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3620 }
3621 }
3622 }
3623 }
3624
3626}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:198
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 969 of file animation.cpp.

971{
972}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3249 of file game.cpp.

3250{
3251 static int previous_turn = -1;
3252 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3253 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3254 auto &mgr = panel_manager::get_manager();
3255 int y = 0;
3256 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3257 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3258 int log_height = 0;
3259 for( const window_panel &panel : mgr.get_current_layout() ) {
3260 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3261 log_height += panel.get_height() + spacer;
3262 }
3263 }
3264 log_height = std::max( TERMY - log_height, 3 );
3265 for( const window_panel &panel : mgr.get_current_layout() ) {
3266 if( panel.render() ) {
3267 // height clamped to window height.
3268 int h = std::min( panel.get_height(), TERMY - y );
3269 if( h == -2 ) {
3270 h = log_height;
3271 }
3272 h += spacer;
3273 if( panel.toggle && panel.render() && h > 0 ) {
3274 if( panel.always_draw || draw_this_turn ) {
3275 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3276 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3277 }
3278 if( show_panel_adm ) {
3279 const std::string panel_name = _( panel.get_name() );
3280 const int panel_name_width = utf8_width( panel_name );
3281 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3282 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3283 werase( label );
3284 mvwprintz( label, point_zero, c_light_red, panel_name );
3286 label = catacurses::newwin( h, 1,
3287 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3288 werase( label );
3289 if( h == 1 ) {
3291 } else {
3293 for( int i = 1; i < h - 1; i++ ) {
3295 }
3296 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3297 }
3299 }
3300 y += h;
3301 }
3302 }
3303 }
3304 previous_turn = current_turn;
3305}
bool show_panel_adm
Definition: game.h:1035
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3307 of file game.cpp.

3308{
3309 w_pixel_minimap = w;
3310}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 846 of file animation.cpp.

847{
848}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 797 of file animation.cpp.

798{
799 draw_sct_curses( *this );
800}
void draw_sct_curses(const game &g)
Definition: animation.cpp:764

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3363 of file game.cpp.

3364{
3366 draw_sounds );
3367}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3369 of file game.cpp.

3370{
3372
3373 m.draw( w_terrain, center );
3374
3375 if( draw_sounds ) {
3377 }
3378
3379 for( Creature &critter : all_creatures() ) {
3380 draw_critter( critter, center );
3381 }
3382
3383 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3384 // Draw auto-move preview trail
3385 const tripoint &final_destination = destination_preview.back();
3386 tripoint line_center = u.pos() + u.view_offset;
3387 draw_line( final_destination, line_center, destination_preview, true );
3388 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3389 POSY - u.posy() ), c_white, 'X' );
3390 }
3391
3392 if( u.controlling_vehicle && !looking ) {
3393 draw_veh_dir_indicator( false );
3394 draw_veh_dir_indicator( true );
3395 }
3396 // Place the cursor over the player as is expected by screen readers.
3397 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3398}
int posx() const override
Definition: character.h:779
int posy() const override
Definition: character.h:782
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3345
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12009
std::vector< tripoint > destination_preview
Definition: game.h:1087
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3415
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:669
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5682
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3035
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 859 of file animation.cpp.

860{
861}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7035 of file game.cpp.

7036{
7037 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7038}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7005

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 898 of file animation.cpp.

899{
900}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3415 of file game.cpp.

3416{
3417 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3418 auto col = next ? c_white : c_dark_gray;
3419 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3420 }
3421}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3400

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 941 of file animation.cpp.

943{
944}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 756 of file animation.cpp.

757{
759}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:737

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 832 of file animation.cpp.

833{
834 draw_zones_curses( w_terrain, start, end, offset );
835}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8077 of file game.cpp.

8078{
8080}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2505
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8082 of file game.cpp.

8083{
8084 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8085 u.drop( game_menus::inv::multidrop( u ), *pnt );
8086 }
8087}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 37 of file dump.cpp.

39{
40 try {
41 loading_ui ui( false );
43 load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
45 } catch( const std::exception &err ) {
46 std::cerr << "Error loading data from json: " << err.what() << std::endl;
47 return false;
48 }
49
50 std::vector<std::string> header;
51 std::vector<std::vector<std::string>> rows;
52
53 int scol = 0; // sorting column
54
55 std::map<std::string, standard_npc> test_npcs;
56 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
57 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
58 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
59 4, 8, 8, 8, 10 /* PER 10 */ );
60 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
61 4, 10, 8, 8, 8 /* STAT 10 */ );
62 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
65 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
66
67 std::map<std::string, item> test_items;
68 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
71 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
72 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
73
74 if( what == "AMMO" ) {
75 header = {
76 "Name", "Ammo", "Volume", "Weight", "Stack",
77 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
78 };
79 auto dump = [&rows]( const item & obj ) {
80 std::vector<std::string> r;
81 r.push_back( obj.tname( 1, false ) );
82 r.push_back( obj.ammo_type().str() );
83 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
84 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
85 r.push_back( std::to_string( obj.type->stack_size ) );
86 r.push_back( std::to_string( obj.type->ammo->range ) );
87 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
88 r.push_back( std::to_string( obj.type->ammo->recoil ) );
89 damage_instance damage = obj.type->ammo->damage;
90 r.push_back( std::to_string( damage.total_damage() ) );
91 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
92 rows.push_back( r );
93 };
94 for( const itype *e : item_controller->all() ) {
95 if( e->ammo ) {
96 dump( item( e, calendar::turn, item::solitary_tag {} ) );
97 }
98 }
99
100 } else if( what == "ARMOR" ) {
101 header = {
102 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
103 };
104 auto dump = [&rows]( const item & obj ) {
105 std::vector<std::string> r;
106 r.push_back( obj.tname( 1, false ) );
107 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
108 r.push_back( std::to_string( obj.get_warmth() ) );
109 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
110 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
111 r.push_back( std::to_string( obj.get_coverage() ) );
112 r.push_back( std::to_string( obj.bash_resist() ) );
113 r.push_back( std::to_string( obj.cut_resist() ) );
114 r.push_back( std::to_string( obj.bullet_resist() ) );
115 r.push_back( std::to_string( obj.acid_resist() ) );
116 r.push_back( std::to_string( obj.fire_resist() ) );
117 rows.push_back( r );
118 };
119
120 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
121
122 for( const itype *e : item_controller->all() ) {
123 if( e->armor ) {
124 item obj( e );
125 if( bp == num_bp || obj.covers( bp ) ) {
126 if( obj.has_flag( flag_VARSIZE ) ) {
127 obj.set_flag( "FIT" );
128 }
129 dump( obj );
130 }
131 }
132 }
133
134 } else if( what == "EDIBLE" ) {
135 header = {
136 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
137 };
138 for( const auto &v : vitamin::all() ) {
139 header.push_back( v.second.name() );
140 }
141 auto dump = [&rows]( const item & obj ) {
142 std::vector<std::string> r;
143 r.push_back( obj.tname( 1, false ) );
144 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
145 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
146 r.push_back( std::to_string( obj.type->stack_size ) );
147 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
148 r.push_back( std::to_string( obj.get_comestible()->quench ) );
149 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
150 auto vits = obj.get_comestible()->default_nutrition.vitamins;
151 for( const auto &v : vitamin::all() ) {
152 r.push_back( std::to_string( vits[ v.first ] ) );
153 }
154 rows.push_back( r );
155 };
156
157 for( const itype *e : item_controller->all() ) {
159
160 if( food.is_food() && g->u.can_eat( food ).success() ) {
161 dump( food );
162 }
163 }
164
165 } else if( what == "GUN" ) {
166 header = {
167 "Name", "Ammo", "Volume", "Weight", "Capacity",
168 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
169 "Aim time", "Effective range", "Snapshot range", "Max range"
170 };
171
172 std::set<std::string> locations;
173 for( const itype *e : item_controller->all() ) {
174 if( e->gun ) {
175 std::transform( e->gun->valid_mod_locations.begin(),
176 e->gun->valid_mod_locations.end(),
177 std::inserter( locations, locations.begin() ),
178 []( const std::pair<gunmod_location, int> &q ) {
179 return q.first.name();
180 } );
181 }
182 }
183 for( const auto &e : locations ) {
184 header.push_back( e );
185 }
186
187 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
188 std::vector<std::string> r;
189 r.push_back( obj.tname( 1, false ) );
190 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
191 obj.ammo_types().end(), []( const ammotype & at ) {
192 return at.str();
194 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
195 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
196 r.push_back( std::to_string( obj.ammo_capacity() ) );
197 r.push_back( std::to_string( obj.gun_range() ) );
198 r.push_back( std::to_string( obj.gun_dispersion() ) );
199 r.push_back( std::to_string( obj.gun_recoil() ) );
200 damage_instance damage = obj.gun_damage();
201 r.push_back( std::to_string( damage.total_damage() ) );
202 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
203
204 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
205
206 for( const auto &e : locations ) {
207 const auto &vml = obj.type->gun->valid_mod_locations;
208 const auto iter = vml.find( e );
209 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
210 }
211 rows.push_back( r );
212 };
213 for( const itype *e : item_controller->all() ) {
214 if( e->gun ) {
215 item gun( e );
216 if( !gun.magazine_integral() ) {
217 gun.put_in( item( gun.magazine_default() ) );
218 }
219 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
220
221 dump( test_npcs[ "S1" ], gun );
222
223 if( gun.type->gun->barrel_length > 0_ml ) {
224 gun.put_in( item( "barrel_small" ) );
225 dump( test_npcs[ "S1" ], gun );
226 }
227 }
228 }
229
230 } else if( what == "RECIPE" ) {
231
232 // optionally filter recipes to include only those using specified skills
233 recipe_subset dict;
234 for( const auto &r : recipe_dict ) {
235 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
236 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
237 return true;
238 }
239 const auto iter = r.second.required_skills.find( skill_id( s ) );
240 return iter != r.second.required_skills.end() && iter->second > 0;
241 } ) ) {
242 dict.include( &r.second );
243 }
244 }
245
246 // only consider skills that are required by at least one recipe
247 std::vector<Skill> sk;
248 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
249 std::back_inserter( sk ), [&dict]( const Skill & s ) {
250 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
251 return r->skill_used == s.ident() ||
252 r->required_skills.find( s.ident() ) != r->required_skills.end();
253 } );
254 } );
255
256 header = { "Result" };
257
258 for( const auto &e : sk ) {
259 header.push_back( e.ident().str() );
260 }
261
262 for( const recipe *e : dict ) {
263 std::vector<std::string> r;
264 r.push_back( e->result_name() );
265 for( const auto &s : sk ) {
266 if( e->skill_used == s.ident() ) {
267 r.push_back( std::to_string( e->difficulty ) );
268 } else {
269 auto iter = e->required_skills.find( s.ident() );
270 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
271 }
272 }
273 rows.push_back( r );
274 }
275
276 } else if( what == "VEHICLE" ) {
277 header = {
278 "Name", "Weight (empty)", "Weight (fueled)",
279 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
280 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
281 };
282 auto dump = [&rows]( const vproto_id & obj ) {
283 vehicle veh_empty( obj, 0, 0 );
284 vehicle veh_fueled( obj, 100, 0 );
285
286 std::vector<std::string> r;
287 r.push_back( veh_empty.name );
288 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
289 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
290 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
294 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
295 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
296 r.push_back( std::to_string( static_cast<int>( 50 *
297 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
298 rows.push_back( r );
299 };
300 for( auto &e : vehicle_prototype::get_all() ) {
301 dump( e );
302 }
303
304 } else if( what == "VPART" ) {
305 header = {
306 "Name", "Location", "Weight", "Size"
307 };
308 auto dump = [&rows]( const vpart_info & obj ) {
309 std::vector<std::string> r;
310 r.push_back( obj.name() );
311 r.push_back( obj.location );
312 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
313 r.push_back( std::to_string( w ) );
314 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
315 rows.push_back( r );
316 };
317 for( const auto &e : vpart_info::all() ) {
318 dump( e.second );
319 }
320
321 } else {
322 std::cerr << "unknown argument: " << what << std::endl;
323 return false;
324 }
325
326 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
327 return e.empty();
328 } ), rows.end() );
329
330 if( scol >= 0 ) {
331 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
332 const std::vector<std::string> &rhs ) {
333 return localized_compare( lhs[ scol ], rhs[ scol ] );
334 } );
335 }
336
337 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
338
339 switch( mode ) {
340 case dump_mode::TSV:
341 rows.insert( rows.begin(), header );
342 for( const auto &r : rows ) {
343 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
344 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
345 std::cout << r.back() << "\n";
346 }
347 break;
348
349 case dump_mode::HTML:
350 std::cout << "<table>";
351
352 std::cout << "<thead>";
353 std::cout << "<tr>";
354 for( const auto &col : header ) {
355 std::cout << "<th>" << col << "</th>";
356 }
357 std::cout << "</tr>";
358 std::cout << "</thead>";
359
360 std::cout << "<tdata>";
361 for( const auto &r : rows ) {
362 std::cout << "<tr>";
363 for( const auto &col : r ) {
364 std::cout << "<td>" << col << "</td>";
365 }
366 std::cout << "</tr>";
367 }
368 std::cout << "</tdata>";
369
370 std::cout << "</table>";
371 break;
372 }
373
374 return true;
375}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2740
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4838
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:989
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:589
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1590
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:679
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:196
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157
string_id< MOD_INFORMATION > mod_id
Definition: type_id.h:91

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 2850 of file game.cpp.

2851{
2852 return *event_bus_ptr;
2853}
pimpl< event_bus > event_bus_ptr
Definition: game.h:974

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5053 of file game.cpp.

5054{
5055 if( veh.magic ) {
5056 add_msg( m_info, _( "This is your %s" ), veh.name );
5057 return;
5058 }
5059 auto act = veh_interact::run( veh, c );
5060 if( act ) {
5061 u.moves = 0;
5063 }
5064}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1866
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5433 of file game.cpp.

5434{
5435 // if we are driving a vehicle, examine the
5436 // current tile without asking.
5437 const optional_vpart_position vp = m.veh_at( u.pos() );
5438 if( vp && vp->vehicle().player_in_control( u ) ) {
5439 examine( u.pos() );
5440 return;
5441 }
5442
5443 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5444 _( "There is nothing that can be examined nearby." ),
5445 ACTION_EXAMINE, false );
5446 if( !examp_ ) {
5447 return;
5448 }
5449 u.manual_examine = true;
5450 examine( *examp_ );
5451 u.manual_examine = false;
5452}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1035
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5433
bool manual_examine
Definition: player.h:615

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5521 of file game.cpp.

5522{
5523 if( disable_robot( examp ) ) {
5524 return;
5525 }
5526
5527 Creature *c = critter_at( examp );
5528 if( c != nullptr ) {
5529 monster *mon = dynamic_cast<monster *>( c );
5530 if( mon != nullptr ) {
5531 add_msg( _( "There is a %s." ), mon->get_name() );
5532 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5533 if( monexamine::pet_menu( *mon ) ) {
5534 return;
5535 }
5536 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5537 if( monexamine::mech_hack( *mon ) ) {
5538 return;
5539 }
5540 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5541 if( monexamine::pay_bot( *mon ) ) {
5542 return;
5543 }
5544 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5545 if( monexamine::mfriend_menu( *mon ) ) {
5546 return;
5547 }
5548 }
5549 } else if( u.is_mounted() ) {
5550 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5551 }
5552 npc *np = dynamic_cast<npc *>( c );
5553 if( np != nullptr && !u.is_mounted() ) {
5554 if( npc_menu( *np ) ) {
5555 return;
5556 }
5557 } else if( np != nullptr && u.is_mounted() ) {
5558 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5559 }
5560 }
5561
5562 const optional_vpart_position vp = m.veh_at( examp );
5563 if( vp && u.is_mounted() ) {
5564 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5565 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5566 } else {
5567 vp->vehicle().interact_with( examp, vp->part_index() );
5568 return;
5569 }
5570 } else if( vp && !u.is_mounted() ) {
5571 vp->vehicle().interact_with( examp, vp->part_index() );
5572 return;
5573 }
5574
5575 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5576 use_computer( examp );
5577 return;
5578 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5579 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5580 }
5581 const furn_t &xfurn_t = m.furn( examp ).obj();
5582 const ter_t &xter_t = m.ter( examp ).obj();
5583
5584 const tripoint player_pos = u.pos();
5585
5586 if( m.has_furn( examp ) && !u.is_mounted() ) {
5587 xfurn_t.examine( u, examp );
5588 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5589 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5590 } else {
5591 if( !u.is_mounted() ) {
5592 xter_t.examine( u, examp );
5593 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5594 xter_t.examine( u, examp );
5595 } else {
5596 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5597 }
5598 }
5599
5600 // Did the player get moved? Bail out if so; our examp probably
5601 // isn't valid anymore.
5602 if( player_pos != u.pos() ) {
5603 return;
5604 }
5605
5606 bool none = true;
5607 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5608 none = false;
5609 }
5610
5611 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5612 iexamine::trap( u, examp );
5613 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5614 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5615 }
5616
5617 // In case of teleport trap or somesuch
5618 if( player_pos != u.pos() ) {
5619 return;
5620 }
5621
5622 // Feedback for fire lasting time, this can be judged while mounted
5623 const std::string fire_fuel = get_fire_fuel_string( examp );
5624 if( !fire_fuel.empty() ) {
5625 add_msg( fire_fuel );
5626 }
5627
5628 if( m.has_flag( "SEALED", examp ) ) {
5629 if( none ) {
5630 if( m.has_flag( "UNSTABLE", examp ) ) {
5631 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5632 } else {
5633 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5634 }
5635 }
5636 } else {
5637 //examp has no traps, is a container and doesn't have a special examination function
5638 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5639 m.has_flag( "CONTAINER", examp ) && none ) {
5640 add_msg( _( "It is empty." ) );
5641 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5642 xfurn_t.examine == &iexamine::fireplace ) ||
5643 xfurn_t.examine == &iexamine::workbench ) {
5644 return;
5645 } else {
5647 if( !u.is_mounted() ) {
5648 pickup::pick_up( examp, 0 );
5649 }
5650 }
5651 }
5652}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1556
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4583
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:8663
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5324
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1338
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5115
ter_id ter(const tripoint &p) const
Definition: map.cpp:1493
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1020
std::string get_name() const override
Definition: monster.cpp:487
static const efftype_id effect_pet("pet")
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5454
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2842
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6029
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:245
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3741
bool pet_menu(monster &z)
Definition: monexamine.cpp:64
bool mech_hack(monster &z)
Definition: monexamine.cpp:373
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:445
bool pay_bot(monster &z)
Definition: monexamine.cpp:405
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 50 of file descriptions.cpp.

51{
53 const int top = 3;
54 int width = 0;
55 catacurses::window w_head;
56 catacurses::window w_main;
57 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
58 const int left = 0;
59 const int right = TERMX;
60 const int bottom = TERMY;
61 width = right - left;
62 const int height = bottom - top;
63 w_head = catacurses::newwin( top, TERMX, point_zero );
64 w_main = catacurses::newwin( height, width, point( left, top ) );
65 ui.position( point_zero, point( TERMX, TERMY ) );
66 } );
67 ui.mark_resize();
68
69 // Default to critter (if any), furniture (if any), then terrain.
71 if( seen_critter( *this, p ) != nullptr ) {
73 } else if( get_map().has_furn( p ) ) {
75 }
76
77 std::string action;
78 input_context ctxt( "EXTENDED_DESCRIPTION" );
79 ctxt.register_action( "CREATURE" );
80 ctxt.register_action( "FURNITURE" );
81 ctxt.register_action( "TERRAIN" );
82 ctxt.register_action( "CONFIRM" );
83 ctxt.register_action( "QUIT" );
84 ctxt.register_action( "HELP_KEYBINDINGS" );
85
86 ui.on_redraw( [&]( const ui_adaptor & ) {
87 werase( w_head );
89 _( "[%s] describe creatures, [%s] describe furniture, "
90 "[%s] describe terrain, [%s] close." ),
91 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
92 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
93
94 // Set up line drawings
95 for( int i = 0; i < TERMX; i++ ) {
96 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
97 }
98
99 wnoutrefresh( w_head );
100
101 std::string desc;
102 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
103 switch( cur_target ) {
105 const Creature *critter = seen_critter( *this, p );
106 if( critter != nullptr ) {
107 desc = critter->extended_description();
108 } else {
109 desc = _( "You do not see any creature here." );
110 }
111 }
112 break;
114 if( !u.sees( p ) || !m.has_furn( p ) ) {
115 desc = _( "You do not see any furniture here." );
116 } else {
117 const furn_id fid = m.furn( p );
118 desc = fid.obj().extended_description();
119 }
120 break;
122 if( !u.sees( p ) ) {
123 desc = _( "You can't see the terrain here." );
124 } else {
125 const ter_id tid = m.ter( p );
126 desc = tid.obj().extended_description();
127 }
128 break;
129 }
130
131 std::string signage = m.get_signage( p );
132 if( !signage.empty() ) {
133 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
134 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
135 signage );
136 }
137
138 werase( w_main );
139 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
140 wnoutrefresh( w_main );
141 } );
142
143 do {
145 action = ctxt.handle_input();
146 if( action == "CREATURE" ) {
147 cur_target = description_target::creature;
148 } else if( action == "FURNITURE" ) {
150 } else if( action == "TERRAIN" ) {
151 cur_target = description_target::terrain;
152 }
153 } while( action != "CONFIRM" && action != "QUIT" );
154}
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:142
std::string get_signage(const tripoint &p) const
Definition: map.cpp:3979
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::string extended_description() const

References _, action, c_light_gray, c_white, creature, map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 6969 of file game.cpp.

6970{
6971 std::map<std::string, map_item_stack> temp_items;
6972 std::vector<map_item_stack> ret;
6973 std::vector<std::string> item_order;
6974
6975 if( u.is_blind() ) {
6976 return ret;
6977 }
6978
6979 for( auto &points_p_it : closest_points_first( u.pos(), iRadius ) ) {
6980 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
6981 u.sees( points_p_it ) &&
6982 m.sees_some_items( points_p_it, u ) ) {
6983
6984 for( auto &elem : m.i_at( points_p_it ) ) {
6985 const std::string name = elem.tname();
6986 const tripoint relative_pos = points_p_it - u.pos();
6987
6988 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
6989 item_order.push_back( name );
6990 temp_items[name] = map_item_stack( &elem, relative_pos );
6991 } else {
6992 temp_items[name].add_at_pos( &elem, relative_pos );
6993 }
6994 }
6995 }
6996 }
6997
6998 for( auto &elem : item_order ) {
6999 ret.push_back( temp_items[elem] );
7000 }
7001
7002 return ret;
7003}
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6341
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), and u.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1956 of file game.cpp.

1957{
1958 return overmap_buffer.find_npc( id ).get();
1959}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10450 of file game.cpp.

10452{
10453 const int omtilesz = SEEX * 2;
10454 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10455 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10456 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10457
10458 // Try to find the stairs.
10460 int best = INT_MAX;
10461 const int movez = z_after - get_levz();
10462 const bool going_down_1 = movez == -1;
10463 const bool going_up_1 = movez == 1;
10464 // If there are stairs on the same x and y as we currently are, use those
10465 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10466 stairs.emplace( u.pos() + tripoint_below );
10467 }
10468 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10469 stairs.emplace( u.pos() + tripoint_above );
10470 }
10471 // We did not find stairs directly above or below, so search the map for them
10472 if( !stairs.has_value() ) {
10473 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10474 if( rl_dist( u.pos(), dest ) <= best &&
10475 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10476 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10477 mp.ter( dest ) == t_manhole_cover ) ) ||
10478 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10479 stairs.emplace( dest );
10480 best = rl_dist( u.pos(), dest );
10481 }
10482 }
10483 }
10484
10485 if( stairs.has_value() ) {
10486 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10487 npc *guy = dynamic_cast<npc *>( blocking_creature );
10488 monster *mon = dynamic_cast<monster *>( blocking_creature );
10489 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10490 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10491 std::string cr_name = blocking_creature->get_name();
10492 std::string msg;
10493 if( guy ) {
10494 //~ %s is the name of hostile NPC
10495 msg = string_format( _( "%s is in the way!" ), cr_name );
10496 } else {
10497 //~ %s is some monster
10498 msg = string_format( _( "There's a %s in the way!" ), cr_name );
10499 }
10500
10501 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
10502 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
10503 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
10504 add_msg( msg );
10505 return cata::nullopt;
10506 }
10507 }
10508 return stairs;
10509 }
10510
10511 // No stairs found! Try to make some
10512 rope_ladder = false;
10513 stairs.emplace( u.pos() );
10514 stairs->z = z_after;
10515 // Check the destination area for lava.
10516 if( mp.ter( *stairs ) == t_lava ) {
10517 if( movez < 0 &&
10518 !query_yn(
10519 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
10520 return cata::nullopt;
10521 } else if( movez > 0 &&
10522 !query_yn(
10523 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
10524 return cata::nullopt;
10525 }
10526
10527 return stairs;
10528 }
10529
10530 if( movez > 0 ) {
10531 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
10532 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
10533 return cata::nullopt;
10534 }
10535 }
10536 // Manhole covers need this to work
10537 // Maybe require manhole cover here and fail otherwise?
10538 return stairs;
10539 }
10540
10541 if( mp.impassable( *stairs ) ) {
10542 popup( _( "Halfway down, the way down becomes blocked off." ) );
10543 return cata::nullopt;
10544 }
10545
10546 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
10547 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
10548 rope_ladder = true;
10549 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
10550 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
10551 } else {
10552 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
10553 }
10554 } else {
10555 return cata::nullopt;
10556 }
10557 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
10558 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
10559 if( u.has_trait( trait_VINES2 ) ) {
10560 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
10561 rope_ladder = true;
10562 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
10563 u.mod_pain( 5 );
10564 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
10565 u.mod_stored_nutr( 10 );
10566 u.mod_thirst( 10 );
10567 } else {
10568 add_msg( _( "You gingerly descend using your vines." ) );
10569 }
10570 } else {
10571 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
10572 rope_ladder = true;
10573 u.mod_stored_nutr( 10 );
10574 u.mod_thirst( 10 );
10575 }
10576 } else {
10577 return cata::nullopt;
10578 }
10579 } else if( u.has_amount( itype_grapnel, 1 ) ) {
10580 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
10581 rope_ladder = true;
10583 } else {
10584 return cata::nullopt;
10585 }
10586 } else if( u.has_amount( itype_rope_30, 1 ) ) {
10587 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
10588 rope_ladder = true;
10590 } else {
10591 return cata::nullopt;
10592 }
10593 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
10594 return cata::nullopt;
10595 }
10596
10597 return stairs;
10598}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8405
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9624
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4414
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4304
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3356
T & emplace(Args &&... args)
Definition: optional.h:143
constexpr bool has_value() const noexcept
Definition: optional.h:120
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8220
bool impassable(const tripoint &p) const
Definition: map.cpp:1790
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8549
bool is_enemy() const
Definition: npc.cpp:2043
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:945
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:9986
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 9789 of file game.cpp.

9791{
9792 if( c == nullptr ) {
9793 debugmsg( "game::fling_creature invoked on null target" );
9794 return;
9795 }
9796
9797 if( c->is_dead_state() ) {
9798 // Flinging a corpse causes problems, don't enable without testing
9799 return;
9800 }
9801
9802 if( c->is_hallucination() ) {
9803 // Don't fling hallucinations
9804 return;
9805 }
9806
9807 bool thru = true;
9808 const bool is_u = ( c == &u );
9809 // Don't animate critters getting bashed if animations are off
9810 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
9811
9812 player *p = dynamic_cast<player *>( c );
9813
9814 tileray tdir( dir );
9815 int range = flvel / 10;
9816 tripoint pt = c->pos();
9817 tripoint prev_point = pt;
9818 bool force_next = false;
9819 tripoint next_forced;
9820 while( range > 0 ) {
9821 c->underwater = false;
9822 // TODO: Check whenever it is actually in the viewport
9823 // or maybe even just redraw the changed tiles
9824 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
9825 if( force_next ) {
9826 pt = next_forced;
9827 force_next = false;
9828 } else {
9829 tdir.advance();
9830 pt.x = c->posx() + tdir.dx();
9831 pt.y = c->posy() + tdir.dy();
9832 }
9833 float force = 0;
9834
9835 if( m.obstructed_by_vehicle_rotation( prev_point, pt ) ) {
9836 //We process the intervening tile on this iteration and then the current tile on the next
9837 next_forced = pt;
9838 force_next = true;
9839 if( one_in( 2 ) ) {
9840 pt.x = prev_point.x;
9841 } else {
9842 pt.y = prev_point.y;
9843 }
9844 }
9845
9846
9847 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
9848 monster &critter = *mon_ptr;
9849 // Approximate critter's "stopping power" with its max hp
9850 force = std::min<float>( 1.5f * critter.type->hp, flvel );
9851 const int damage = rng( force, force * 2.0f ) / 6;
9852 c->impact( damage, pt );
9853 // Multiply zed damage by 6 because no body parts
9854 const int zed_damage = std::max( 0,
9855 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
9856 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
9857 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
9858 critter.check_dead_state();
9859 if( !critter.is_dead() ) {
9860 thru = false;
9861 }
9862 } else if( m.impassable( pt ) ) {
9863 if( !m.veh_at( pt ).obstacle_at_part() ) {
9864 force = std::min<float>( m.bash_strength( pt ), flvel );
9865 } else {
9866 // No good way of limiting force here
9867 // Keep it 1 less than maximum to make the impact hurt
9868 // but to keep the target flying after it
9869 force = flvel - 1;
9870 }
9871 const int damage = rng( force, force * 2.0f ) / 9;
9872 c->impact( damage, pt );
9873 if( m.is_bashable( pt ) ) {
9874 // Only go through if we successfully make the tile passable
9875 m.bash( pt, flvel );
9876 thru = m.passable( pt );
9877 } else {
9878 thru = false;
9879 }
9880 }
9881
9882 // If the critter dies during flinging, moving it around causes debugmsgs
9883 if( c->is_dead_state() ) {
9884 return;
9885 }
9886
9887 flvel -= force;
9888 if( thru ) {
9889 if( p != nullptr ) {
9890 if( p->in_vehicle ) {
9891 m.unboard_vehicle( p->pos() );
9892 }
9893 // If we're flinging the player around, make sure the map stays centered on them.
9894 if( is_u && !suppress_map_update ) {
9895 update_map( pt.x, pt.y );
9896 } else {
9897 p->setpos( pt );
9898 }
9899 } else if( !critter_at( pt ) ) {
9900 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
9901 // Just don't setpos if it happens - next iteration will do so
9902 // or the monster will stop a tile before the unpassable one
9903 c->setpos( pt );
9904 }
9905 } else {
9906 // Don't zero flvel - count this as slamming both the obstacle and the ground
9907 // although at lower velocity
9908 break;
9909 }
9910 //Vehicle wall tiles don't count for range
9911 if( !force_next ) {
9912 range--;
9913 }
9914 prev_point = pt;
9915 if( animate && ( seen || u.sees( *c ) ) ) {
9919 }
9920 }
9921
9922 // Fall down to the ground - always on the last reached tile
9923 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
9924 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
9925 // Didn't smash into a wall or a floor so only take the fall damage
9926 if( thru && trap_under_creature == tr_ledge ) {
9927 m.creature_on_trap( *c, false );
9928 } else {
9929 // Fall on ground
9930 int force = rng( flvel, flvel * 2 ) / 9;
9931 if( controlled ) {
9932 force = std::max( force / 2 - 5, 0 );
9933 }
9934 if( force > 0 ) {
9935 int dmg = c->impact( force, c->pos() );
9936 // TODO: Make landing damage the floor
9937 m.bash( c->pos(), dmg / 4, false, false, false );
9938 }
9939 // Always apply traps to creature i.e. bear traps, tele traps etc.
9940 m.creature_on_trap( *c, false );
9941 }
9942 } else {
9943 c->underwater = true;
9944 if( is_u ) {
9945 if( controlled ) {
9946 add_msg( _( "You dive into water." ) );
9947 } else {
9948 add_msg( m_warning, _( "You fall into water." ) );
9949 }
9950 }
9951 }
9952}
void setpos(const tripoint &p) override
Definition: character.h:797
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1839
point update_map(player &p)
Definition: game.cpp:10677
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2444
bool obstructed_by_vehicle_rotation(const tripoint &from, const tripoint &to) const
Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.
Definition: map.cpp:6464
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3506
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1076
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2409
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8426
bool passable(const tripoint &p) const
Definition: map.cpp:1795
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1859
bool is_dead() const
Definition: monster.cpp:2757
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1640
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Definition: ui_manager.cpp:290
int hp
Definition: mtype.h:267
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::obstructed_by_vehicle_rotation(), one_in(), map::passable(), Character::pos(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5066 of file game.cpp.

5067{
5068 // TODO: Z
5069 const int &x = p.x;
5070 const int &y = p.y;
5071 const std::string &door_name = door_type.obj().name();
5072 // sed when player/monsters are knocked back and when moving items out of the way
5073 point kb( x, y );
5074 const auto valid_location = [&]( const tripoint & p ) {
5075 return g->is_empty( p );
5076 };
5078 valid_location ) ) {
5079 kb.x = -pos->x + x + x;
5080 kb.y = -pos->y + y + y;
5081 }
5082 const tripoint kbp( kb, p.z );
5083 if( kbp == p ) {
5084 // can't pushback any creatures anywhere, that means the door can't close.
5085 return false;
5086 }
5087 const bool can_see = u.sees( tripoint( x, y, p.z ) );
5088 player *npc_or_player = critter_at<player>( tripoint( x, y, p.z ), false );
5089 if( npc_or_player != nullptr ) {
5090 if( bash_dmg <= 0 ) {
5091 return false;
5092 }
5093 if( npc_or_player->is_npc() && can_see ) {
5094 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5095 } else if( npc_or_player->is_player() ) {
5096 add_msg( m_bad, _( "The %s hits you." ), door_name );
5097 }
5098 if( npc_or_player->activity ) {
5099 npc_or_player->cancel_activity();
5100 }
5101 // TODO: make the npc angry?
5102 npc_or_player->hitall( bash_dmg, 0, nullptr );
5103 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5104 // TODO: perhaps damage/destroy the gate
5105 // if the npc was really big?
5106 }
5107 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5108 monster &critter = *mon_ptr;
5109 if( bash_dmg <= 0 ) {
5110 return false;
5111 }
5112 if( can_see ) {
5113 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5114 }
5115 if( critter.type->size <= MS_SMALL ) {
5116 critter.die_in_explosion( nullptr );
5117 } else {
5118 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5119 critter.check_dead_state();
5120 }
5121 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5122 // big critters simply prevent the gate from closing
5123 // TODO: perhaps damage/destroy the gate
5124 // if the critter was really big?
5125 return false;
5126 }
5127 if( !critter.is_dead() ) {
5128 // Still alive? Move the critter away so the door can close
5129 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5130 if( critter_at( p ) ) {
5131 return false;
5132 }
5133 }
5134 }
5135 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5136 if( bash_dmg <= 0 ) {
5137 return false;
5138 }
5139 vp->vehicle().damage( vp->part_index(), bash_dmg );
5140 if( m.veh_at( p ) ) {
5141 // Check again in case all parts at the door tile
5142 // have been destroyed, if there is still a vehicle
5143 // there, the door can not be closed
5144 return false;
5145 }
5146 }
5147 if( bash_dmg < 0 && !m.i_at( point( x, y ) ).empty() ) {
5148 return false;
5149 }
5150 if( bash_dmg == 0 ) {
5151 for( auto &elem : m.i_at( point( x, y ) ) ) {
5152 if( elem.made_of( LIQUID ) ) {
5153 // Liquids are OK, will be destroyed later
5154 continue;
5155 } else if( elem.volume() < 250_ml ) {
5156 // Dito for small items, will be moved away
5157 continue;
5158 }
5159 // Everything else prevents the door from closing
5160 return false;
5161 }
5162 }
5163
5164 m.ter_set( point( x, y ), door_type );
5165 if( m.has_flag( "NOITEM", point( x, y ) ) ) {
5166 map_stack items = m.i_at( point( x, y ) );
5167 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5168 if( it->made_of( LIQUID ) ) {
5169 it = items.erase( it );
5170 continue;
5171 }
5172 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5173 if( can_see ) {
5174 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5175 } else {
5176 add_msg( m_warning, _( "Something shatters!" ) );
5177 }
5178 it = items.erase( it );
5179 continue;
5180 }
5181 m.add_item_or_charges( kbp, *it );
5182 it = items.erase( it );
5183 }
5184 }
5185 return true;
5186}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8673
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
Definition: game.cpp:4345
iterator erase(const_iterator it) override
Definition: map.cpp:148
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1634
void die_in_explosion(Creature *source)
Definition: monster.cpp:1654
bool is_npc() const override
Definition: player.h:122
bool is_player() const override
Definition: player.h:105
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:259

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, map::veh_at(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 630 of file game.cpp.

631{
632 return gamemode ? gamemode->id() : SGAME_NULL;
633}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12024 of file game.cpp.

12025{
12026 for( Creature &critter : all_creatures() ) {
12027 if( pred( critter ) ) {
12028 return &critter;
12029 }
12030 }
12031 return nullptr;
12032}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 11934 of file game.cpp.

11936{
11937 std::vector<Creature *> result;
11938 for( Creature &critter : all_creatures() ) {
11939 if( pred( critter ) ) {
11940 result.push_back( &critter );
11941 }
11942 }
11943 return result;
11944}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 11914 of file game.cpp.

11915{
11916 // The player is located in the middle submap of the map.
11918 const tripoint pos_om = sm_to_om_copy( sm );
11919 // TODO: fix point types
11920 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
11921}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8230
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8746 of file game.cpp.

8747{
8748 std::vector<std::string> harmful_stuff;
8749 const auto fields_here = m.field_at( u.pos() );
8750 for( const auto &e : m.field_at( dest_loc ) ) {
8751 // warn before moving into a dangerous field except when already standing within a similar field
8752 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
8753 harmful_stuff.push_back( e.second.name() );
8754 }
8755 }
8756
8757 if( !u.is_blind() ) {
8758 const trap &tr = m.tr_at( dest_loc );
8759 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
8760 true ) );
8761 // HACK: Hack for now, later ledge should stop being a trap
8762 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
8763 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
8764 if( !boardable ) {
8765 harmful_stuff.emplace_back( tr.name() );
8766 }
8767 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
8768 harmful_stuff.emplace_back( tr.name() );
8769 }
8770
8771 static const std::set< body_part > sharp_bps = {
8774 };
8775
8776 const auto sharp_bp_check = [this]( body_part bp ) {
8777 return u.immune_to( bp, { DT_CUT, 10 } );
8778 };
8779
8780 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
8781 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
8782 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
8783 harmful_stuff.emplace_back( m.name( dest_loc ) );
8784 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
8785 m.veh_at( dest_loc ) ) &&
8786 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
8787 harmful_stuff.emplace_back( m.name( dest_loc ) );
8788 }
8789
8790 }
8791
8792 return harmful_stuff;
8793}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:248
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6969
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5277
bool has_zlevels() const
Definition: map.h:1677
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:928
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3732 of file game.cpp.

3733{
3734 // We're going to get the contiguous fishable terrain starting at
3735 // the provided fishing location (e.g. where a line was cast or a fish
3736 // trap was set), and then check whether or not fishable monsters are
3737 // actually in those locations. This will help us ensure that we're
3738 // getting our fish from the location that we're ACTUALLY fishing,
3739 // rather than just somewhere in the vicinity.
3740
3741 std::unordered_set<tripoint> visited;
3742
3743 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3744 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3745
3746 const inclusive_cuboid<tripoint> fishing_boundaries(
3747 fishing_boundary_min, fishing_boundary_max );
3748
3749 const auto get_fishable_terrain = [&]( tripoint starting_point,
3750 std::unordered_set<tripoint> &fishable_terrain ) {
3751 std::queue<tripoint> to_check;
3752 to_check.push( starting_point );
3753 while( !to_check.empty() ) {
3754 const tripoint current_point = to_check.front();
3755 to_check.pop();
3756
3757 // We've been here before, so bail.
3758 if( visited.find( current_point ) != visited.end() ) {
3759 continue;
3760 }
3761
3762 // This point is out of bounds, so bail.
3763 if( !fishing_boundaries.contains( current_point ) ) {
3764 continue;
3765 }
3766
3767 // Mark this point as visited.
3768 visited.emplace( current_point );
3769
3770 if( m.has_flag( "FISHABLE", current_point ) ) {
3771 fishable_terrain.emplace( current_point );
3772 to_check.push( current_point + point_south );
3773 to_check.push( current_point + point_north );
3774 to_check.push( current_point + point_east );
3775 to_check.push( current_point + point_west );
3776 }
3777 }
3778 return;
3779 };
3780
3781 // Starting at the provided location, get our fishable terrain
3782 // and populate a set with those locations which we'll then use
3783 // to determine if any fishable monsters are in those locations.
3784 std::unordered_set<tripoint> fishable_points;
3785 get_fishable_terrain( fish_pos, fishable_points );
3786
3787 return fishable_points;
3788}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 3790 of file game.cpp.

3792{
3793 std::vector<monster *> unique_fish;
3794 for( monster &critter : all_monsters() ) {
3795 // If it is fishable...
3796 if( critter.has_flag( MF_FISHABLE ) ) {
3797 const tripoint critter_pos = critter.pos();
3798 // ...and it is in a fishable location.
3799 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
3800 unique_fish.push_back( &critter );
3801 }
3802 }
3803 }
3804
3805 return unique_fish;
3806}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2053 of file game.cpp.

2054{
2055 return follower_ids;
2056}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 969 of file game.cpp.

970{
971 return *kill_tracker_ptr;
972}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 11899 of file game.cpp.

11900{
11901 return m.get_abs_sub().x;
11902}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 11904 of file game.cpp.

11905{
11906 return m.get_abs_sub().y;
11907}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7139 of file game.cpp.

7140{
7141 return moves_since_last_save;
7142}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 11946 of file game.cpp.

11947{
11948 std::vector<npc *> result;
11949 for( npc &guy : all_npcs() ) {
11950 if( pred( guy ) ) {
11951 result.push_back( &guy );
11952 }
11953 }
11954 return result;
11955}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12034 of file game.cpp.

12035{
12036 return get_world_base_save_path() + "/" + base64_encode( u.name );
12037}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12039

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 237 of file handle_action.cpp.

238{
239 input_context ctxt;
240 if( uquit == QUIT_WATCH ) {
241 ctxt = input_context( "DEFAULTMODE" );
242 ctxt.set_iso( true );
243 // The list of allowed actions in death-cam mode in game::handle_action
244 // *INDENT-OFF*
245 for( const action_id id : {
258 } ) {
259 ctxt.register_action( action_ident( id ) );
260 }
261 // *INDENT-ON*
262 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
263 } else {
265 }
266
268
269 user_turn current_turn;
270
271
272 // Checking early if we will need to handle animations
273 // If we do not need to handle animations that will not change as long as the user has not selected an action
274 // and we can handle it like we are not animating.
275 weather_printable wPrint;
276 bool animate_weather = false;
277 bool animate_sct = false;
278 bool do_animations = [&]() {
279 if( get_option<bool>( "ANIMATIONS" ) ) {
280 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
281
282 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
283 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
284
285#if defined(TILES)
286 // Always animate, minimap and terrain may have animations to run
287 return true;
288#else
289 // Otherwise we need to see if we actually should animate.
290 // Minimap and Terrain never animate in !TILES
291 return animate_weather || animate_sct || uquit == QUIT_WATCH;
292#endif
293 }
294 return false;
295 }
296 ();
297
298 if( do_animations ) {
299 ctxt.set_timeout( 125 );
300
302 make_shared_fast<game::draw_callback_t>( [&]() {
303 if( animate_weather ) {
304 draw_weather( wPrint );
305 }
306 if( animate_sct ) {
307 draw_sct();
308 }
309 } );
310 add_draw_callback( animation_cb );
311 invalidate_main_ui_adaptor(); // We want to redraw at least once.
312
313 do {
314 if( animate_weather ) {
316 generate_weather_anim_frame( get_weather().weather_id, wPrint );
317 }
318 // don't bother calculating SCT if we won't show it
319 if( animate_sct ) {
321
323
324 //Check for creatures on all drawing positions and offset if necessary
325 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
326 const direction oCurDir = iter->getDirecton();
327 const int width = utf8_width( iter->getText() );
328 for( int i = 0; i < width; ++i ) {
329 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
330 const Creature *critter = critter_at( tmp, true );
331
332 if( critter != nullptr && u.sees( *critter ) ) {
333 i = -1;
334 int iPos = iter->getStep() + iter->getStepOffset();
335 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
336 if( iter2->getDirecton() == oCurDir &&
337 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
338 if( iter2->getType() == "hp" ) {
339 iter2->advanceStepOffset();
340 }
341
342 iter2->advanceStepOffset();
343 iPos = iter2->getStep() + iter2->getStepOffset();
344 }
345 }
346 }
347 }
348 }
349
350 // Stop animation when done
351 animate_sct = !SCT.vSCT.empty();
352 }
353 // We don't cache these checks as their result may change after 1st redraw
355 // TODO: we redraw *everything* just to animate a couple blinking dots
356 // on the minimap or a few tiles.
357 // This is far from ideal, and can probably be done much cheaper
358 // (update only part of the screen? draw static parts into a texture?)
360 }
361
362 std::unique_ptr<static_popup> deathcam_msg_popup;
363 if( uquit == QUIT_WATCH ) {
364 deathcam_msg_popup = std::make_unique<static_popup>();
365 deathcam_msg_popup
366 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
367 .on_top( true );
368 }
369
371 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
372 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
373 ctxt.reset_timeout();
374 } else {
377 SCT.vSCT.clear();
378
379 ctxt.set_timeout( 125 );
380 while( handle_mouseview( ctxt, action ) ) {
381 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
382 break;
383 }
384 }
385 ctxt.reset_timeout();
386 }
387
388 return ctxt;
389}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:68
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:257
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1136
bool minimap_requires_animation()
Definition: animation.cpp:1127
void draw_sct()
Definition: animation.cpp:797
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:756
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3145
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2084
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:947
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2184
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1865 of file game.cpp.

1866{
1867 return seed;
1868}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7144 of file game.cpp.

7145{
7146 return user_action_counter;
7147}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3400 of file game.cpp.

3401{
3402 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3403 return cata::nullopt;
3404 }
3405 const optional_vpart_position vp = m.veh_at( u.pos() );
3406 if( !vp ) {
3407 return cata::nullopt;
3408 }
3409 vehicle *const veh = &vp->vehicle();
3410 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3411 float r = 10.0;
3412 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3413}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12039 of file game.cpp.

12040{
12041 if( world_generator->active_world == nullptr ) {
12042 return PATH_INFO::savedir();
12043 }
12044 return world_generator->active_world->folder_path();
12045}
std::string savedir()
Definition: path_info.cpp:250

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7130 of file game.cpp.

7131{
7132#if defined(TILES)
7133 return tileset_zoom;
7134#else
7135 return DEFAULT_TILESET_ZOOM;
7136#endif
7137}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 9549 of file game.cpp.

9550{
9551 // Furniture: pull, push, or standing still and nudging object around.
9552 // Can push furniture out of reach.
9553 tripoint fpos = u.pos() + u.grab_point;
9554 // supposed position of grabbed furniture
9555 if( !m.has_furn( fpos ) ) {
9556 // Where did it go? We're grabbing thin air so reset.
9557 add_msg( m_info, _( "No furniture at grabbed point." ) );
9558 u.grab( OBJECT_NONE );
9559 return false;
9560 }
9561
9562 const bool pushing_furniture = dp == u.grab_point;
9563 const bool pulling_furniture = dp == -u.grab_point;
9564 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
9565
9566 tripoint fdest = fpos + dp; // intended destination of furniture.
9567 // Check floor: floorless tiles don't need to be flat and have no traps
9568 const bool has_floor = m.has_floor( fdest );
9569 // Unfortunately, game::is_empty fails for tiles we're standing on,
9570 // which will forbid pulling, so:
9571 const bool canmove = (
9572 m.passable( fdest ) &&
9573 critter_at<npc>( fdest ) == nullptr &&
9574 critter_at<monster>( fdest ) == nullptr &&
9575 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
9576 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
9577 !m.has_furn( fdest ) &&
9578 !m.veh_at( fdest ) &&
9579 ( !has_floor || m.tr_at( fdest ).is_null() )
9580 );
9581
9582 const furn_t furntype = m.furn( fpos ).obj();
9583 const int src_items = m.i_at( fpos ).size();
9584 const int dst_items = m.i_at( fdest ).size();
9585
9586 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
9587 [&]( item & liquid_item ) {
9588 return liquid_item.made_of( LIQUID );
9589 } );
9590
9591 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
9592 !m.has_flag( "SWIMMABLE", fdest ) &&
9593 !m.has_flag( "DESTROY_ITEM", fdest );
9594
9595 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
9596 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
9597 m.furn( fpos ).obj().has_flag( "SEALED" );
9598
9599 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
9600 time_duration fire_age = m.get_field_age( fpos, fd_fire );
9601
9602 int str_req = furntype.move_str_req;
9603 // Factor in weight of items contained in the furniture.
9604 units::mass furniture_contents_weight = 0_gram;
9605 for( auto &contained_item : m.i_at( fpos ) ) {
9606 furniture_contents_weight += contained_item.weight();
9607 }
9608 str_req += furniture_contents_weight / 4_kilogram;
9609 if( !canmove ) {
9610 // TODO: What is something?
9611 add_msg( _( "The %s collides with something." ), furntype.name() );
9612 u.moves -= 50;
9613 return true;
9614 ///\EFFECT_STR determines ability to drag furniture
9615 } else if( str_req > u.get_str() &&
9616 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
9617 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
9618 furntype.name() );
9619 u.moves -= 100;
9620 u.mod_pain( 1 ); // Hurt ourselves.
9621 return true; // furniture and or obstacle wins.
9622 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
9623 add_msg( _( "There's stuff in the way." ) );
9624 u.moves -= 50;
9625 return true;
9626 }
9627
9628 u.moves -= str_req * 10;
9629 // Additional penalty if we can't comfortably move it.
9630 if( str_req > u.get_str() ) {
9631 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
9632 if( move_penalty <= 1000 ) {
9633 if( u.get_str() >= str_req - 3 ) {
9634 u.moves -= std::max( 3000, move_penalty * 10 );
9635 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
9636 if( one_in( 3 ) ) {
9637 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
9638 return true;
9639 }
9640 } else {
9641 u.moves -= 100;
9642 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
9643 return true;
9644 }
9645 }
9646 u.moves -= move_penalty;
9647 if( move_penalty > 500 ) {
9648 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
9649 furntype.name() );
9650 } else if( move_penalty > 200 ) {
9651 if( one_in( 3 ) ) { // Nag only occasionally.
9652 add_msg( _( "It takes some time to move the heavy %s." ),
9653 furntype.name() );
9654 }
9655 }
9656 }
9658 _( "a scraping noise." ), true, "misc", "scraping" );
9659
9661 ( tripoint_abs_ms( m.getabs( fpos ) ) );
9662
9663 // Actually move the furniture.
9664 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
9665 m.furn_set( fpos, f_null );
9666
9667 if( fire_intensity == 1 && !pulling_furniture ) {
9668 m.remove_field( fpos, fd_fire );
9669 m.set_field_intensity( fdest, fd_fire, fire_intensity );
9670 m.set_field_age( fdest, fd_fire, fire_age );
9671 }
9672
9673 // Is there is only liquids on the ground, remove them after moving furniture.
9674 if( dst_items > 0 && only_liquid_items ) {
9675 m.i_clear( fdest );
9676 }
9677
9678 if( src_items > 0 ) { // Move the stuff inside.
9679 if( dst_item_ok && src_item_ok ) {
9680 // Assume contents of both cells are legal, so we can just swap contents.
9681 std::list<item> temp;
9682 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
9683 std::back_inserter( temp ) );
9684 m.i_clear( fpos );
9685 for( auto item_iter = m.i_at( fdest ).begin();
9686 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
9687 m.i_at( fpos ).insert( *item_iter );
9688 }
9689 m.i_clear( fdest );
9690 for( auto &cur_item : temp ) {
9691 m.i_at( fdest ).insert( cur_item );
9692 }
9693 } else {
9694 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
9695 }
9696 }
9697
9698 if( shifting_furniture ) {
9699 // We didn't move
9700 tripoint d_sum = u.grab_point + dp;
9701 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
9702 u.grab_point = d_sum; // furniture moved relative to us
9703 } else { // we pushed furniture out of reach
9704 add_msg( _( "You let go of the %s." ), furntype.name() );
9705 u.grab( OBJECT_NONE );
9706 }
9707 return true; // We moved furniture but stayed still.
9708 }
9709
9710 if( pushing_furniture && m.impassable( fpos ) ) {
9711 // Not sure how that chair got into a wall, but don't let player follow.
9712 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
9713 furntype.name(), m.tername( fdest ) );
9714 u.grab( OBJECT_NONE );
9715 return true;
9716 }
9717
9718 return false;
9719}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4064
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:648
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:4920
void insert(const item &newitem) override
Definition: map.cpp:153
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5443
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5317
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5351
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5357
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5330
std::string tername(const tripoint &p) const
Definition: map.cpp:1704
void i_clear(const tripoint &p)
Definition: map.cpp:4107
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1355
bool has_floor(const tripoint &p) const
Definition: map.cpp:2002
tripoint grab_point
Definition: player.h:601
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:505
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 9721 of file game.cpp.

9722{
9723 if( u.get_grab_type() == OBJECT_NONE ) {
9724 return false;
9725 }
9726
9727 if( dp.z != 0 ) {
9728 // No dragging stuff up/down stairs yet!
9729 return false;
9730 }
9731
9732 // vehicle: pulling, pushing, or moving around the grabbed object.
9733 if( u.get_grab_type() == OBJECT_VEHICLE ) {
9734 return grabbed_veh_move( dp );
9735 }
9736
9737 if( u.get_grab_type() == OBJECT_FURNITURE ) {
9738 return grabbed_furn_move( dp );
9739 }
9740
9741 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
9743 u.grab( OBJECT_NONE );
9744 return false;
9745}
object_type get_grab_type() const
Definition: avatar.cpp:656
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:9549
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150 grabbed_vehicle->adjust_zlevel( 1, dp );
151
152 // Grabbed part has to stay at distance 1 to the player
153 // and in roughly the same direction.
154 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
155 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
156 const tripoint expected_pos = u.pos() + dp + from;
157 const tripoint actual_dir = expected_pos - new_part_pos;
158
159 // Set player location to illegal value so it can't collide with vehicle.
160 const tripoint player_prev = u.pos();
162 std::vector<veh_collision> colls;
163 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
164 u.setpos( player_prev );
165 if( !colls.empty() ) {
166 blocker_name = colls.front().target_name;
167 }
168 return failed ? tripoint_zero : actual_dir;
169 };
170
171 // First try the move as intended
172 // But if that fails and the move is a zig-zag, try to recover:
173 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
174 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
175 if( final_dp_veh == tripoint_zero && zigzag ) {
176 final_dp_veh = get_move_dir( -prev_grab, -dp );
177 next_grab = -dp;
178 }
179
180 if( final_dp_veh == tripoint_zero ) {
181 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
182 u.grab_point = prev_grab;
183 return true;
184 }
185
186 u.grab_point = next_grab;
187
188 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
189
190 if( grabbed_vehicle ) {
191 grabbed_vehicle->shift_zlevel();
192 grabbed_vehicle->check_falling_or_floating();
193 } else {
194 debugmsg( "Grabbed vehicle disappeared" );
195 return false;
196 }
197
198 for( int p : wheel_indices ) {
199 if( one_in( 2 ) ) {
200 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
201 grabbed_vehicle->handle_trap( wheel_p, p );
202 }
203 }
204
205 return false;
206
207}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1114
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1775
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5826
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3281
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3150
bool valid_wheel_config() const
Definition: vehicle.cpp:4459
units::mass total_mass() const
Definition: vehicle.cpp:3306
std::vector< int > wheelcache
Definition: vehicle.h:1818
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1948
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6968
int part_count() const
Definition: vehicle.cpp:7075
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3262
vehicle_part & part(int part_num)
Definition: vehicle.cpp:7080
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3286
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1927
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1513 of file handle_action.cpp.

1514{
1515 std::string action;
1516 input_context ctxt;
1518 user_turn current_turn;
1519 // Check if we have an auto-move destination
1520 if( u.has_destination() ) {
1522 if( act == ACTION_NULL ) {
1523 add_msg( m_info, _( "Auto-move canceled" ) );
1525 return false;
1526 }
1527 } else if( u.has_destination_activity() ) {
1528 // starts destination activity after the player successfully reached his destination
1530 return false;
1531 } else {
1532 // No auto-move, ask player for input
1533 ctxt = get_player_input( action );
1534 }
1535
1536 const optional_vpart_position vp = m.veh_at( u.pos() );
1537 bool veh_ctrl = !u.is_dead_state() &&
1538 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1539
1540 // If performing an action with right mouse button, co-ordinates
1541 // of location clicked.
1542 cata::optional<tripoint> mouse_target;
1543
1544 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1545 uquit = QUIT_DIED;
1546 return false;
1547 }
1548
1549 if( act == ACTION_NULL ) {
1551
1552 if( act == ACTION_KEYBINDINGS ) {
1553 // already handled by input context
1554 return false;
1555 }
1556
1557 if( act == ACTION_MAIN_MENU ) {
1558 if( uquit == QUIT_WATCH ) {
1559 return false;
1560 }
1561 // No auto-move actions have or can be set at this point.
1563 destination_preview.clear();
1565 if( act == ACTION_NULL ) {
1566 return false;
1567 }
1568 }
1569
1570 if( act == ACTION_ACTIONMENU ) {
1571 if( uquit == QUIT_WATCH ) {
1572 return false;
1573 }
1574 // No auto-move actions have or can be set at this point.
1576 destination_preview.clear();
1578 if( act == ACTION_NULL ) {
1579 return false;
1580 }
1581#if defined(__ANDROID__)
1582 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1583 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1584 }
1585#endif
1586 }
1587
1588 if( act == ACTION_KEYBINDINGS ) {
1590 destination_preview.clear();
1591 act = ctxt.display_menu( true );
1592 if( act == ACTION_NULL ) {
1593 return false;
1594 }
1595 }
1596
1599 }
1600
1601 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1602 // Mouse button click
1603 if( veh_ctrl ) {
1604 // No mouse use in vehicle
1605 return false;
1606 }
1607
1608 if( u.is_dead_state() ) {
1609 // do not allow mouse actions while dead
1610 return false;
1611 }
1612
1613 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1614 if( !mouse_pos ) {
1615 return false;
1616 } else if( !u.sees( *mouse_pos ) ) {
1617 // Not clicked in visible terrain
1618 return false;
1619 }
1620 mouse_target = mouse_pos;
1621
1622 if( act == ACTION_SELECT ) {
1623 // Note: The following has the potential side effect of
1624 // setting auto-move destination state in addition to setting
1625 // act.
1626 if( !try_get_left_click_action( act, *mouse_target ) ) {
1627 return false;
1628 }
1629 } else if( act == ACTION_SEC_SELECT ) {
1630 if( !try_get_right_click_action( act, *mouse_target ) ) {
1631 return false;
1632 }
1633 }
1634 } else if( act != ACTION_TIMEOUT ) {
1635 // act has not been set for an auto-move, so clearing possible
1636 // auto-move destinations. Since initializing an auto-move with
1637 // the mouse may span across multiple actions, we do not clear the
1638 // auto-move destination if the action is only a timeout, as this
1639 // would require the user to double click quicker than the
1640 // timeout delay.
1642 destination_preview.clear();
1643 }
1644 }
1645
1646 if( act == ACTION_NULL ) {
1647 const input_event &&evt = ctxt.get_raw_input();
1648 if( !evt.sequence.empty() ) {
1649 const int ch = evt.get_first_input();
1650 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1651 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1652 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1653 if( const cata::optional<std::string> hint =
1655 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1656 "the current context." ),
1657 *hint );
1658 }
1659 }
1660 }
1661 return false;
1662 }
1663
1664 // This has no action unless we're in a special game mode.
1665 gamemode->pre_action( act );
1666
1667 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1668
1669 int before_action_moves = u.moves;
1670
1671 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1672 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1673 switch( act ) {
1676 break;
1677
1678 case ACTION_CENTER:
1681 break;
1682
1683 case ACTION_SHIFT_N:
1684 case ACTION_SHIFT_NE:
1685 case ACTION_SHIFT_E:
1686 case ACTION_SHIFT_SE:
1687 case ACTION_SHIFT_S:
1688 case ACTION_SHIFT_SW:
1689 case ACTION_SHIFT_W:
1690 case ACTION_SHIFT_NW: {
1691 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1700 };
1702 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1703 }
1704 break;
1705
1706 case ACTION_LOOK:
1707 look_around();
1708 break;
1709
1710 case ACTION_KEYBINDINGS:
1711 // already handled by input context
1712 break;
1713
1714 default:
1715 break;
1716 }
1717 }
1718
1719 // actions allowed only while alive
1720 if( !u.is_dead_state() ) {
1721 switch( act ) {
1722 case ACTION_NULL:
1723 case NUM_ACTIONS:
1724 break; // dummy entries
1725 case ACTION_ACTIONMENU:
1726 case ACTION_MAIN_MENU:
1727 case ACTION_KEYBINDINGS:
1728 break; // handled above
1729
1730 case ACTION_TIMEOUT:
1731 if( check_safe_mode_allowed( false ) ) {
1732 u.pause();
1733 }
1734 break;
1735
1736 case ACTION_PAUSE:
1737 if( check_safe_mode_allowed() ) {
1738 u.pause();
1739 }
1740 break;
1741
1742 case ACTION_CYCLE_MOVE:
1744 break;
1745
1746 case ACTION_RESET_MOVE:
1748 break;
1749
1750 case ACTION_TOGGLE_RUN:
1752 break;
1753
1756 break;
1757
1760 break;
1761
1762 case ACTION_MOVE_FORTH:
1764 case ACTION_MOVE_RIGHT:
1766 case ACTION_MOVE_BACK:
1768 case ACTION_MOVE_LEFT:
1770 if( !u.get_value( "remote_controlling" ).empty() &&
1774 } else if( veh_ctrl ) {
1775 // vehicle control uses x for steering and y for ac/deceleration,
1776 // so no rotation needed
1778 } else {
1780 if( auto_travel_mode && !u.is_auto_moving() ) {
1781 for( int i = 0; i < SEEX; i++ ) {
1782 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1783 u.posy() + dest_delta.y * ( SEEX - i ),
1784 u.posz() );
1786 auto_travel_destination,
1788 u.get_path_avoid() );
1789 if( !destination_preview.empty() ) {
1792 break;
1793 }
1794 }
1797 if( dest_next == point_zero ) {
1799 }
1800 dest_delta = dest_next;
1801 }
1802 if( !avatar_action::move( u, m, dest_delta ) ) {
1803 // auto-move should be canceled due to a failed move or obstacle
1805 }
1806 }
1807 break;
1808 case ACTION_MOVE_DOWN:
1809 if( u.is_mounted() ) {
1810 auto mon = u.mounted_creature.get();
1811 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1812 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1813 break;
1814 }
1815 }
1816 if( !u.in_vehicle ) {
1817 vertical_move( -1, false );
1818 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1820 }
1821 break;
1822
1823 case ACTION_MOVE_UP:
1824 if( u.is_mounted() ) {
1825 auto mon = u.mounted_creature.get();
1826 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1827 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1828 break;
1829 }
1830 }
1831 if( !u.in_vehicle ) {
1832 vertical_move( 1, false );
1833 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1835 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1836 !vp->vehicle().has_sufficient_rotorlift() ) {
1837 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1838 }
1839 break;
1840
1841 case ACTION_OPEN:
1843 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1844 } else if( u.is_mounted() ) {
1845 add_msg( m_info, _( "You can't open things while you're riding." ) );
1846 } else {
1847 open();
1848 }
1849 break;
1850
1851 case ACTION_CLOSE:
1853 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1854 } else if( u.is_mounted() ) {
1855 auto mon = u.mounted_creature.get();
1856 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1857 add_msg( m_info, _( "You can't close things while you're riding." ) );
1858 }
1859 } else if( mouse_target ) {
1860 doors::close_door( m, u, *mouse_target );
1861 } else {
1862 close();
1863 }
1864 break;
1865
1866 case ACTION_SMASH:
1867 if( veh_ctrl ) {
1868 handbrake();
1869 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1870 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1871 } else {
1872 smash();
1873 }
1874 break;
1875
1876 case ACTION_EXAMINE:
1878 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1879 } else if( mouse_target ) {
1880 examine( *mouse_target );
1881 } else {
1882 examine();
1883 }
1884 break;
1885
1886 case ACTION_ADVANCEDINV:
1888 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1889 } else if( u.is_mounted() ) {
1890 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1891 } else {
1893 }
1894 break;
1895
1896 case ACTION_PICKUP:
1898 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1899 } else if( u.is_mounted() ) {
1900 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1901 } else if( mouse_target ) {
1902 pickup( *mouse_target );
1903 } else {
1904 pickup();
1905 }
1906 break;
1907
1908 case ACTION_PICKUP_FEET:
1910 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1911 } else {
1912 pickup_feet();
1913 }
1914 break;
1915
1916 case ACTION_GRAB:
1918 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1919 } else if( u.is_mounted() ) {
1920 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1921 } else {
1922 grab();
1923 }
1924 break;
1925
1926 case ACTION_HAUL:
1928 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1929 } else if( u.is_mounted() ) {
1930 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1931 } else {
1932 haul();
1933 }
1934 break;
1935
1936 case ACTION_BUTCHER:
1938 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1939 } else if( u.is_mounted() ) {
1940 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1941 } else {
1942 butcher();
1943 }
1944 break;
1945
1946 case ACTION_CHAT:
1947 chat();
1948 break;
1949
1950 case ACTION_PEEK:
1952 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1953 } else if( u.is_mounted() ) {
1954 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1955 } else {
1956 peek();
1957 }
1958 break;
1959
1960 case ACTION_LIST_ITEMS:
1962 break;
1963
1964 case ACTION_ZONES:
1965 zones_manager();
1966 break;
1967
1968 case ACTION_LOOT:
1969 loot();
1970 break;
1971
1972 case ACTION_INVENTORY:
1974 break;
1975
1976 case ACTION_COMPARE:
1978 break;
1979
1980 case ACTION_ORGANIZE:
1982 break;
1983
1984 case ACTION_USE:
1985 // Shell-users are presumed to be able to mess with their inventories, etc
1986 // while in the shell. Eating, gear-changing, and item use are OK.
1988 break;
1989
1990 case ACTION_USE_WIELDED:
1991 u.use_wielded();
1992 break;
1993
1994 case ACTION_WEAR:
1995 wear();
1996 break;
1997
1998 case ACTION_TAKE_OFF:
1999 takeoff();
2000 break;
2001
2002 case ACTION_EAT:
2003 if( !avatar_action::eat_here( u ) ) {
2005 }
2006 break;
2007
2009 if( !avatar_action::eat_here( u ) ) {
2011 }
2012 break;
2013
2014 case ACTION_READ:
2015 // Shell-users are presumed to have the book just at an opening and read it that way
2016 read();
2017 break;
2018
2019 case ACTION_WIELD:
2021 break;
2022
2023 case ACTION_PICK_STYLE:
2024 u.martial_arts_data->pick_style( u );
2025 break;
2026
2027 case ACTION_RELOAD_ITEM:
2029 break;
2030
2033 break;
2034
2037 break;
2038
2039 case ACTION_UNLOAD:
2041 break;
2042
2043 case ACTION_MEND:
2045 break;
2046
2047 case ACTION_THROW: {
2048 item_location loc;
2049 avatar_action::plthrow( g->u, loc );
2050 break;
2051 }
2052
2053 case ACTION_FIRE:
2054 fire();
2055 break;
2056
2057 case ACTION_CAST_SPELL:
2058 cast_spell();
2059 break;
2060
2061 case ACTION_FIRE_BURST: {
2062 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2064 }
2065 break;
2066 }
2067
2069 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2070 if( u.weapon.gun_all_modes().size() > 1 ) {
2072 } else {
2073 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2074 }
2075 }
2076 break;
2077
2079 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2081 }
2082 break;
2083
2084 case ACTION_DROP:
2085 // You CAN drop things to your own tile while in the shell.
2086 drop();
2087 break;
2088
2089 case ACTION_DIR_DROP:
2091 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2092 } else {
2094 }
2095 break;
2096 case ACTION_BIONICS:
2097 u.power_bionics();
2098 break;
2099 case ACTION_MUTATIONS:
2101 break;
2102
2103 case ACTION_SORT_ARMOR:
2104 u.sort_armor();
2105 break;
2106
2107 case ACTION_WAIT:
2108 wait();
2109 break;
2110
2111 case ACTION_CRAFT:
2113 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2114 } else if( u.is_mounted() ) {
2115 add_msg( m_info, _( "You can't craft while you're riding." ) );
2116 } else {
2117 u.craft();
2118 }
2119 break;
2120
2121 case ACTION_RECRAFT:
2123 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2124 } else if( u.is_mounted() ) {
2125 add_msg( m_info, _( "You can't craft while you're riding." ) );
2126 } else {
2127 u.recraft();
2128 }
2129 break;
2130
2131 case ACTION_LONGCRAFT:
2133 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2134 } else if( u.is_mounted() ) {
2135 add_msg( m_info, _( "You can't craft while you're riding." ) );
2136 } else {
2137 u.long_craft();
2138 }
2139 break;
2140
2141 case ACTION_DISASSEMBLE:
2142 if( u.controlling_vehicle ) {
2143 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2144 } else if( u.is_mounted() ) {
2145 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2146 } else {
2147 u.disassemble();
2148 }
2149 break;
2150
2151 case ACTION_CONSTRUCT:
2152 if( u.in_vehicle ) {
2153 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2154 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2155 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2156 } else if( u.is_mounted() ) {
2157 add_msg( m_info, _( "You can't construct while you're riding." ) );
2158 } else {
2159 construction_menu( false );
2160 }
2161 break;
2162
2163 case ACTION_SLEEP:
2164 if( veh_ctrl ) {
2165 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2166 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2167 _( "new default binding is '^'." ) ) );
2168 } else {
2169 sleep();
2170 }
2171 break;
2172
2175 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2176 } else if( u.is_mounted() ) {
2177 u.dismount();
2178 } else {
2180 }
2181 break;
2182
2185 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2186 break;
2187
2189 if( safe_mode == SAFE_MODE_OFF ) {
2191 mostseen = 0;
2192 add_msg( m_info, _( "Safe mode ON!" ) );
2193 } else {
2196 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2197 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2198 }
2202 }
2203 break;
2204
2206 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2207 add_msg( m_info, autosafemode_option.value_as<bool>()
2208 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2209 autosafemode_option.setNext();
2210 break;
2211 }
2212
2214 if( safe_mode == SAFE_MODE_STOP ) {
2215 add_msg( m_info, _( "Ignoring enemy!" ) );
2216 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2217 monster &critter = *elem;
2218 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2219 }
2221 } else if( u.has_effect( effect_laserlocked ) ) {
2222 if( u.has_trait( trait_PROF_CHURL ) ) {
2223 add_msg( m_warning, _( "You make the sign of the cross." ) );
2224 } else {
2225 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2226 }
2229 }
2230 break;
2231
2233 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2235 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2237 mostseen = 0;
2238 } else {
2239 get_safemode().show();
2240 }
2241 break;
2242
2243 case ACTION_SUICIDE:
2244 if( query_yn( _( "Commit suicide?" ) ) ) {
2245 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2246 u.moves = 0;
2247 u.place_corpse();
2249 }
2250 }
2251 break;
2252
2253 case ACTION_SAVE:
2254 if( query_yn( _( "Save and quit?" ) ) ) {
2255 if( save() ) {
2256 u.moves = 0;
2257 uquit = QUIT_SAVED;
2258 }
2259 }
2260 break;
2261
2262 case ACTION_QUICKSAVE:
2263 quicksave();
2264 return false;
2265
2266 case ACTION_QUICKLOAD:
2267 quickload();
2268 return false;
2269
2270 case ACTION_PL_INFO:
2272 break;
2273
2274 case ACTION_MAP:
2276 break;
2277
2278 case ACTION_SKY:
2279 if( m.is_outside( u.pos() ) ) {
2281 } else {
2282 add_msg( m_info, _( "You can't see the sky from here." ) );
2283 }
2284 break;
2285
2286 case ACTION_MISSIONS:
2287 list_missions();
2288 break;
2289
2290 case ACTION_SCORES:
2292 break;
2293
2294 case ACTION_FACTIONS:
2295 faction_manager_ptr->display();
2296 break;
2297
2298 case ACTION_MORALE:
2299 u.disp_morale();
2300 break;
2301
2302 case ACTION_MESSAGES:
2304 break;
2305
2306 case ACTION_HELP:
2308 break;
2309
2310 case ACTION_OPTIONS:
2311 get_options().show( true );
2312 break;
2313
2314 case ACTION_AUTOPICKUP:
2316 break;
2317
2318 case ACTION_AUTONOTES:
2320 break;
2321
2322 case ACTION_SAFEMODE:
2323 get_safemode().show();
2324 break;
2325
2326 case ACTION_COLOR:
2327 all_colors.show_gui();
2328 break;
2329
2330 case ACTION_WORLD_MODS:
2331 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2332 break;
2333
2334 case ACTION_DEBUG:
2336 break; //don't do anything when sharing and not debugger
2337 }
2339 break;
2340
2343 break;
2344
2347 break;
2348
2351 break;
2352
2355 break;
2356
2358 get_options().get_option( "AUTO_FEATURES" ).setNext();
2359 get_options().save();
2360 //~ Auto Features are now ON/OFF
2361 add_msg( _( "%s are now %s." ),
2362 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2363 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2364 break;
2365
2367 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2368 get_options().save();
2369 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2370 add_msg( _( "%s is now set to %s." ),
2371 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2372 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2373 break;
2374
2376 get_options().get_option( "AUTO_MINING" ).setNext();
2377 get_options().save();
2378 //~ Auto Mining is now ON/OFF
2379 add_msg( _( "%s is now %s." ),
2380 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2381 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2382 break;
2383
2385 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2386 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2387 u.set_value( "THIEF_MODE_KEEP", "YES" );
2388 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2389 add_msg( _( "You will not pick up other peoples belongings." ) );
2390 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2391 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2392 u.set_value( "THIEF_MODE_KEEP", "YES" );
2393 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2394 add_msg( _( "You will pick up also those things that belong to others!" ) );
2395 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2396 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2397 u.set_value( "THIEF_MODE_KEEP", "NO" );
2398 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2399 add_msg( _( "You will be reminded not to steal." ) );
2400 } else {
2401 // ERROR
2402 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2403 }
2404 break;
2405
2407 get_options().get_option( "AUTO_FORAGING" ).setNext();
2408 get_options().save();
2409 //~ Auto Foraging is now set to x
2410 add_msg( _( "%s is now set to %s." ),
2411 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2412 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2413 break;
2414
2416 get_options().get_option( "AUTO_PICKUP" ).setNext();
2417 get_options().save();
2418 //~ Auto pickup is now set to x
2419 add_msg( _( "%s is now set to %s." ),
2420 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2421 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2422 break;
2423
2426 break; //don't do anything when sharing and not debugger
2427 }
2428 display_scent();
2429 break;
2430
2433 break; //don't do anything when sharing and not debugger
2434 }
2435 display_scent();
2436 break;
2437
2440 break; //don't do anything when sharing and not debugger
2441 }
2443 break;
2446 break; //don't do anything when sharing and not debugger
2447 }
2449 break;
2452 break; //don't do anything when sharing and not debugger
2453 }
2455 break;
2456
2459 break; //don't do anything when sharing and not debugger
2460 }
2462 break;
2463
2466 break; //don't do anything when sharing and not debugger
2467 }
2469 break;
2470
2473 break; //don't do anything when sharing and not debugger
2474 }
2476 break;
2477
2479 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2480 break;
2481
2484 break;
2485
2488 break; //don't do anything when sharing and not debugger
2489 }
2491 if( debug_mode ) {
2492 add_msg( m_info, _( "Debug mode ON!" ) );
2493 } else {
2494 add_msg( m_info, _( "Debug mode OFF!" ) );
2495 }
2496 break;
2497
2498 case ACTION_ZOOM_IN:
2499 zoom_in();
2501 break;
2502
2503 case ACTION_ZOOM_OUT:
2504 zoom_out();
2506 break;
2507
2508 case ACTION_ITEMACTION:
2510 break;
2511
2512 case ACTION_AUTOATTACK:
2514 break;
2515
2516 default:
2517 break;
2518 }
2519 }
2520 if( act != ACTION_TIMEOUT ) {
2521 u.mod_moves( -current_turn.moves_elapsed() );
2522 }
2523 gamemode->post_action( act );
2524
2525 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2526 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2527 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2528 return ( !u.is_dead_state() );
2529}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:469
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:348
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:418
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:941
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:507
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:655
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:265
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:259
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:263
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:267
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:261
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:269
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1525
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2561
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9944
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9958
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1247
item weapon
Definition: character.h:1521
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1331
std::string get_value(const std::string &key) const
Definition: creature.cpp:1341
void mod_moves(int nmoves)
Definition: creature.cpp:1408
void cycle_move_mode()
Definition: avatar.cpp:1165
void toggle_map_memory()
Definition: avatar.cpp:119
void toggle_crouch_mode()
Definition: avatar.cpp:1149
void toggle_run_mode()
Definition: avatar.cpp:1140
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:980
void reset_move_mode()
Definition: avatar.cpp:1158
void item_action_menu()
void display_radiation()
Definition: game.cpp:11277
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2377
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:8657
cata::optional< tripoint > look_around()
Definition: game.cpp:6619
void pickup_feet()
Definition: game.cpp:5676
void zones_manager()
Definition: game.cpp:6144
int turnssincelastmon
Definition: game.h:1042
void display_visibility()
Definition: game.cpp:11191
void display_scent()
Definition: game.cpp:11156
bool save()
Returns false if saving failed.
Definition: game.cpp:2870
void butcher()
Definition: game.cpp:8339
void display_temperature()
Definition: game.cpp:11177
bool auto_travel_mode
Definition: game.h:1039
void zoom_out()
Definition: game.cpp:7086
void toggle_pixel_minimap()
Definition: game.cpp:511
void toggle_debug_hour_timer()
Definition: game.cpp:11223
void display_transparency()
Definition: game.cpp:11284
void list_items_monsters()
Definition: game.cpp:7263
void chat()
Definition: npctalk.cpp:394
void quickload()
Definition: game.cpp:11319
void pickup()
Definition: game.cpp:5654
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10004
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11251
void control_vehicle()
Definition: game.cpp:5224
void peek()
Definition: game.cpp:5683
void drop()
Definition: game.cpp:8077
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2405
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:8595
void zoom_in()
Definition: game.cpp:7098
void toggle_fullscreen()
Definition: game.cpp:501
void display_vehicle_ai()
Definition: game.cpp:11184
void reload_tileset()
Definition: game.cpp:522
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3118
void drop_in_direction()
Definition: game.cpp:8082
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6361
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7752
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4700
bool is_gunmod() const
Definition: item.cpp:6391
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7671
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7743
bool is_outside(const tripoint &p) const
Definition: map.cpp:2558
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:255
short ignoring
Definition: monster.h:507
cOpt & get_option(const std::string &name)
Definition: options.cpp:3334
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2722
void show_adm()
Definition: panels.cpp:2406
void pause()
Definition: player.cpp:609
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:341
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3058
int movecounter
Definition: player.h:613
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:352
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:361
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
construction_id construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void reload_wielded(bool prompt=false)
Reload wielded item.
void reload_item()
Prompt to reload some item.
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void wield()
Prompt to wield some item.
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void reload_weapon(bool try_everything=true)
Reload a wielded gun/tool.
void mend(avatar &you, item_location loc)
void unload(avatar &you)
Prompts to unload some item.
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3754
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, auto_travel_mode, avatar_action::autoattack(), bio_remote, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, player::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), avatar_action::reload_item(), reload_tileset(), avatar_action::reload_weapon(), avatar_action::reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), avatar_action::wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2058 of file game.cpp.

2059{
2061 const std::string action = ctxt.handle_input( 0 );
2062 bool refresh = true;
2063 if( action == "pause" ) {
2065 cancel_activity_query( _( "Confirm:" ) );
2066 }
2067 } else if( action == "player_data" ) {
2069 } else if( action == "messages" ) {
2071 } else if( action == "help" ) {
2073 } else if( action != "HELP_KEYBINDINGS" ) {
2074 refresh = false;
2075 }
2076 if( refresh ) {
2079 }
2080}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1842
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2084 of file game.cpp.

2085{
2086 cata::optional<tripoint> liveview_pos;
2087
2088 do {
2089 action = ctxt.handle_input();
2090 if( action == "MOUSE_MOVE" ) {
2091 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2092 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2093 liveview_pos = mouse_pos;
2094 liveview.show( *liveview_pos );
2095 } else if( !mouse_pos ) {
2096 liveview_pos.reset();
2097 liveview.hide();
2098 }
2100 }
2101 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2102
2103 if( action != "TIMEOUT" ) {
2104 // Keyboard event, break out of animation loop
2105 liveview.hide();
2106 return false;
2107 }
2108
2109 // Mouse movement or un-handled key
2110 return true;
2111}
void reset() noexcept
Definition: optional.h:155
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 625 of file game.cpp.

626{
627 return gamemode && gamemode->id() != SGAME_NULL;
628}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11291 of file game.cpp.

11292{
11294 last_save_timestamp = time( nullptr );
11295}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 396 of file game_inventory.cpp.

398{
400 title, radius, none_message );
401}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:330

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 434 of file game.cpp.

435{
437}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8724 of file game.cpp.

8725{
8726 return !( get_dangerous_tile( dest_loc ).empty() );
8727}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8746

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 4920 of file game.cpp.

4921{
4922 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
4923 critter_at( p ) == nullptr;
4924}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2450 of file game.cpp.

2451{
2452 if( uquit == QUIT_WATCH ) {
2453 // deny player movement and dodging
2454 u.moves = 0;
2455 // prevent pain from updating
2456 u.set_pain( 0 );
2457 // prevent dodging
2458 u.dodges_left = 0;
2459 return false;
2460 }
2461 if( uquit == QUIT_DIED ) {
2462 if( u.in_vehicle ) {
2463 m.unboard_vehicle( u.pos() );
2464 }
2465 u.place_corpse();
2466 return true;
2467 }
2468 if( uquit == QUIT_SUICIDE ) {
2469 if( u.in_vehicle ) {
2470 m.unboard_vehicle( u.pos() );
2471 }
2472 return true;
2473 }
2474 if( uquit != QUIT_NO ) {
2475 return true;
2476 }
2477 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2478 if( u.is_dead_state() ) {
2480 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2481 uquit = QUIT_WATCH;
2482 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2483 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2485 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2486 uquit = QUIT_DIED;
2487 } else {
2488 // Something funky happened here, just die.
2489 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2490 uquit = QUIT_DIED;
2491 }
2492 return is_game_over();
2493 }
2494 return false;
2495}
int dodges_left
Definition: character.h:559
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:972
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:190
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3709 of file game.cpp.

3710{
3711 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3712 get_option<int>( "SAFEMODEPROXIMITY" );
3713 return is_hostile_within( distance );
3714}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3721

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3716 of file game.cpp.

3717{
3719}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:192

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3721 of file game.cpp.

3722{
3723 for( auto &critter : u.get_visible_creatures( distance ) ) {
3724 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3725 return critter;
3726 }
3727 }
3728
3729 return nullptr;
3730}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 4926 of file game.cpp.

4927{
4928 return weather::is_in_sunlight( m, p, get_weather().weather_id );
4929}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3355 of file game.cpp.

3356{
3357 const tripoint diff( u.pos() + u.view_offset - p );
3358
3359 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3360 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3361}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 4931 of file game.cpp.

4932{
4933 return weather::is_sheltered( m, p );
4934}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6074 of file game.cpp.

6075{
6076 return zones_manager_open;
6077}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1074

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1519
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1234
void restack(player &p)
Definition: inventory.cpp:398
void unsort()
Definition: inventory.cpp:226
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult 
)

Definition at line 4345 of file game.cpp.

4346{
4347 std::vector<tripoint> traj;
4348 traj.clear();
4349 traj = line_to( s, t, 0, 0 );
4350 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4351 traj = continue_line( traj, force );
4352 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4353
4354 knockback( traj, stun, dam_mult );
4355}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult 
)

Definition at line 4361 of file game.cpp.

4362{
4363 // TODO: make the force parameter actually do something.
4364 // the header file says higher force causes more damage.
4365 // perhaps that is what it should do?
4366
4367 // TODO: refactor this so it's not copy/pasted 3 times
4368 tripoint tp = traj.front();
4369 if( !critter_at( tp ) ) {
4370 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4371 return;
4372 }
4373 std::size_t force_remaining = traj.size();
4374 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4375 if( stun > 0 ) {
4376 targ->add_effect( effect_stunned, 1_turns * stun );
4377 add_msg( _( "%s was stunned!" ), targ->name() );
4378 }
4379 for( size_t i = 1; i < traj.size(); i++ ) {
4380 if( m.impassable( traj[i].xy() ) || m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) {
4381 targ->setpos( traj[i - 1] );
4382 force_remaining = traj.size() - i;
4383 if( stun != 0 ) {
4384 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4385 add_msg( _( "%s was stunned!" ), targ->name() );
4386 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4387 targ->apply_damage( nullptr, bodypart_id( "torso" ), dam_mult * force_remaining );
4388 targ->check_dead_state();
4389 }
4390 m.bash( traj[i], 2 * dam_mult * force_remaining );
4391 break;
4392 } else if( critter_at( traj[i] ) ) {
4393 targ->setpos( traj[i - 1] );
4394 force_remaining = traj.size() - i;
4395 if( stun != 0 ) {
4396 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4397 add_msg( _( "%s was stunned!" ), targ->name() );
4398 }
4399 traj.erase( traj.begin(), traj.begin() + i );
4400 if( critter_at<monster>( traj.front() ) ) {
4401 add_msg( _( "%s collided with something else and sent it flying!" ),
4402 targ->name() );
4403 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4404 if( guy->male ) {
4405 add_msg( _( "%s collided with someone else and sent him flying!" ),
4406 targ->name() );
4407 } else {
4408 add_msg( _( "%s collided with someone else and sent her flying!" ),
4409 targ->name() );
4410 }
4411 } else if( u.pos() == traj.front() ) {
4412 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4413 }
4414 knockback( traj, stun, dam_mult );
4415 break;
4416 }
4417 targ->setpos( traj[i] );
4418 if( m.has_flag( "LIQUID", targ->pos() ) && !targ->can_drown() && !targ->is_dead() ) {
4419 targ->die( nullptr );
4420 if( u.sees( *targ ) ) {
4421 add_msg( _( "The %s drowns!" ), targ->name() );
4422 }
4423 }
4424 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4425 !targ->is_dead() ) {
4426 targ->die( nullptr );
4427 if( u.sees( *targ ) ) {
4428 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4429 }
4430 }
4431 tp = traj[i];
4432 }
4433 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4434 if( stun > 0 ) {
4435 targ->add_effect( effect_stunned, 1_turns * stun );
4436 add_msg( _( "%s was stunned!" ), targ->name );
4437 }
4438 for( size_t i = 1; i < traj.size(); i++ ) {
4439 if( m.impassable( traj[i].xy() ) ||
4440 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4441 targ->setpos( traj[i - 1] );
4442 force_remaining = traj.size() - i;
4443 if( stun != 0 ) {
4444 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4445 if( targ->has_effect( effect_stunned ) ) {
4446 add_msg( _( "%s was stunned!" ), targ->name );
4447 }
4448
4449 std::array<bodypart_id, 8> bps = {{
4450 bodypart_id( "head" ),
4451 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4452 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4453 bodypart_id( "torso" ),
4454 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4455 }
4456 };
4457 for( const bodypart_id &bp : bps ) {
4458 if( one_in( 2 ) ) {
4459 targ->deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4460 }
4461 }
4462 targ->check_dead_state();
4463 }
4464 m.bash( traj[i], 2 * dam_mult * force_remaining );
4465 break;
4466 } else if( critter_at( traj[i] ) ) {
4467 targ->setpos( traj[i - 1] );
4468 force_remaining = traj.size() - i;
4469 if( stun != 0 ) {
4470 add_msg( _( "%s was stunned!" ), targ->name );
4471 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4472 }
4473 traj.erase( traj.begin(), traj.begin() + i );
4474 const tripoint &traj_front = traj.front();
4475 if( critter_at<monster>( traj_front ) ) {
4476 add_msg( _( "%s collided with something else and sent it flying!" ),
4477 targ->name );
4478 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4479 if( guy->male ) {
4480 add_msg( _( "%s collided with someone else and sent him flying!" ),
4481 targ->name );
4482 } else {
4483 add_msg( _( "%s collided with someone else and sent her flying!" ),
4484 targ->name );
4485 }
4486 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4488 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4489 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4490 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4491 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4492 }
4493 knockback( traj, stun, dam_mult );
4494 break;
4495 }
4496 targ->setpos( traj[i] );
4497 tp = traj[i];
4498 }
4499 } else if( u.pos() == tp ) {
4500 if( stun > 0 ) {
4501 u.add_effect( effect_stunned, 1_turns * stun );
4502 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4503 "You were stunned for %d turns!",
4504 stun ),
4505 stun );
4506 }
4507 for( size_t i = 1; i < traj.size(); i++ ) {
4508 if( m.impassable( traj[i] ) ||
4509 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4510 u.setpos( traj[i - 1] );
4511 force_remaining = traj.size() - i;
4512 if( stun != 0 ) {
4513 if( u.has_effect( effect_stunned ) ) {
4514 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4515 "You were stunned AGAIN for %d turns!",
4516 force_remaining ),
4517 force_remaining );
4518 } else {
4519 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4520 "You were stunned for %d turns!",
4521 force_remaining ),
4522 force_remaining );
4523 }
4524 u.add_effect( effect_stunned, 1_turns * force_remaining );
4525 std::array<bodypart_id, 8> bps = {{
4526 bodypart_id( "head" ),
4527 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4528 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4529 bodypart_id( "torso" ),
4530 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4531 }
4532 };
4533 for( const bodypart_id &bp : bps ) {
4534 if( one_in( 2 ) ) {
4535 u.deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4536 }
4537 }
4539 }
4540 m.bash( traj[i], 2 * dam_mult * force_remaining );
4541 break;
4542 } else if( critter_at( traj[i] ) ) {
4543 u.setpos( traj[i - 1] );
4544 force_remaining = traj.size() - i;
4545 if( stun != 0 ) {
4546 if( u.has_effect( effect_stunned ) ) {
4547 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4548 "You were stunned AGAIN for %d turns!",
4549 force_remaining ),
4550 force_remaining );
4551 } else {
4552 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4553 "You were stunned for %d turns!",
4554 force_remaining ),
4555 force_remaining );
4556 }
4557 u.add_effect( effect_stunned, 1_turns * force_remaining );
4558 }
4559 traj.erase( traj.begin(), traj.begin() + i );
4560 if( critter_at<monster>( traj.front() ) ) {
4561 add_msg( _( "You collided with something and sent it flying!" ) );
4562 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4563 if( guy->male ) {
4564 add_msg( _( "You collided with someone and sent him flying!" ) );
4565 } else {
4566 add_msg( _( "You collided with someone and sent her flying!" ) );
4567 }
4568 }
4569 knockback( traj, stun, dam_mult );
4570 break;
4571 }
4572 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4573 avatar_action::swim( m, u, u.pos() );
4574 } else {
4575 u.setpos( traj[i] );
4576 }
4577
4578 tp = traj[i];
4579 }
4580 }
4581}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8933
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8457
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:980
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, map::obstructed_by_vehicle_rotation(), one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3688 of file game.cpp.

3689{
3690 const float light = natural_light_level( zlev );
3691 return LIGHT_RANGE( light );
3692}
float natural_light_level(int zlev) const
Definition: game.cpp:3628
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 2895 of file game.cpp.

2896{
2897 std::vector<std::string> saves;
2898 for( auto &worldsave : world_generator->active_world->world_saves ) {
2899 saves.push_back( worldsave.player_name() );
2900 }
2901 return saves;
2902}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7308 of file game.cpp.

7309{
7310 std::vector<map_item_stack> ground_items = item_list;
7311 int iInfoHeight = 0;
7312 int iMaxRows = 0;
7313 int width = 0;
7314 int max_name_width = 0;
7315
7316 //find max length of item name and resize window width
7317 for( const map_item_stack &cur_item : ground_items ) {
7318 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7319 if( item_len > max_name_width ) {
7320 max_name_width = item_len;
7321 }
7322 }
7323
7324 tripoint active_pos;
7325 map_item_stack *activeItem = nullptr;
7326
7327 catacurses::window w_items;
7328 catacurses::window w_items_border;
7329 catacurses::window w_item_info;
7330
7331 ui_adaptor ui;
7332 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7333 iInfoHeight = std::min( 25, TERMY / 2 );
7334 iMaxRows = TERMY - iInfoHeight - 2;
7335
7336 width = clamp( max_name_width, 45, TERMX / 3 );
7337
7338 const int offsetX = TERMX - width;
7339
7340 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7341 width - 2, point( offsetX + 1, 1 ) );
7342 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7343 width, point( offsetX, 0 ) );
7344 w_item_info = catacurses::newwin( iInfoHeight, width,
7345 point( offsetX, TERMY - iInfoHeight ) );
7346
7347 if( activeItem ) {
7348 centerlistview( active_pos, width );
7349 }
7350
7351 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7352 } );
7353 ui.mark_resize();
7354
7355 // use previously selected sorting method
7356 bool sort_radius = uistate.list_item_sort != 2;
7357 bool addcategory = !sort_radius;
7358
7359 // reload filter/priority settings on the first invocation, if they were active
7360 if( !uistate.list_item_init ) {
7363 }
7366 }
7369 }
7370 uistate.list_item_init = true;
7371 }
7372
7373 //this stores only those items that match our filter
7374 std::vector<map_item_stack> filtered_items =
7375 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7376 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7377 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7378 int iItemNum = ground_items.size();
7379
7380 const tripoint stored_view_offset = u.view_offset;
7381
7383
7384 int iActive = 0; // Item index that we're looking at
7385 bool refilter = true;
7386 int page_num = 0;
7387 int iCatSortNum = 0;
7388 int iScrollPos = 0;
7389 std::map<int, std::string> mSortCategory;
7390
7391 std::string action;
7392 input_context ctxt( "LIST_ITEMS" );
7393 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7394 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7395 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7396 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7397 ctxt.register_action( "PAGE_DOWN" );
7398 ctxt.register_action( "PAGE_UP" );
7399 ctxt.register_action( "NEXT_TAB" );
7400 ctxt.register_action( "PREV_TAB" );
7401 ctxt.register_action( "HELP_KEYBINDINGS" );
7402 ctxt.register_action( "QUIT" );
7403 ctxt.register_action( "FILTER" );
7404 ctxt.register_action( "RESET_FILTER" );
7405 ctxt.register_action( "EXAMINE" );
7406 ctxt.register_action( "COMPARE" );
7407 ctxt.register_action( "PRIORITY_INCREASE" );
7408 ctxt.register_action( "PRIORITY_DECREASE" );
7409 ctxt.register_action( "SORT" );
7410 ctxt.register_action( "TRAVEL_TO" );
7411
7413
7414 ui.on_redraw( [&]( const ui_adaptor & ) {
7415 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7416
7417 if( ground_items.empty() ) {
7418 wnoutrefresh( w_items_border );
7419 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7420 } else {
7421 int iStartPos = 0;
7422 werase( w_items );
7423 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7424 int iNum = 0;
7425 bool high = false;
7426 bool low = false;
7427 int index = 0;
7428 int iCatSortOffset = 0;
7429
7430 for( int i = 0; i < iStartPos; i++ ) {
7431 if( !mSortCategory[i].empty() ) {
7432 iNum++;
7433 }
7434 }
7435 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7436 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7437 high = true;
7438 low = false;
7439 } else if( index >= lowPStart + iCatSortOffset ) {
7440 high = false;
7441 low = true;
7442 } else {
7443 high = false;
7444 low = false;
7445 }
7446
7447 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7448 int iThisPage = 0;
7449 if( !mSortCategory[iNum].empty() ) {
7450 iCatSortOffset++;
7451 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7452 } else {
7453 if( iNum == iActive ) {
7454 iThisPage = page_num;
7455 }
7456 std::string sText;
7457 if( iter->vIG.size() > 1 ) {
7458 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7459 }
7460 sText += iter->example->tname();
7461 if( iter->vIG[iThisPage].count > 1 ) {
7462 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7463 }
7464
7465 nc_color col = c_light_green;
7466 if( iNum != iActive ) {
7467 if( high ) {
7468 col = c_yellow;
7469 } else if( low ) {
7470 col = c_red;
7471 } else {
7472 col = iter->example->color_in_inventory();
7473 }
7474 }
7475 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7476 const int numw = iItemNum > 9 ? 2 : 1;
7477 const int x = iter->vIG[iThisPage].pos.x;
7478 const int y = iter->vIG[iThisPage].pos.y;
7479 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7480 iNum == iActive ? c_light_green : c_light_gray,
7481 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7483 ++iter;
7484 }
7485 } else {
7486 ++iter;
7487 }
7488 iNum++;
7489 }
7490 iNum = 0;
7491 for( int i = 0; i < iActive; i++ ) {
7492 if( !mSortCategory[i].empty() ) {
7493 iNum++;
7494 }
7495 }
7496 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7497 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7498 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7499 werase( w_item_info );
7500
7501 if( iItemNum > 0 && activeItem ) {
7502 std::vector<iteminfo> vThisItem;
7503 std::vector<iteminfo> vDummy;
7504 activeItem->example->info( true, vThisItem );
7505
7506 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7507 dummy.without_getch = true;
7508 dummy.without_border = true;
7509
7510 draw_item_info( w_item_info, dummy );
7511 }
7512 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7513 wnoutrefresh( w_items_border );
7514 }
7515
7516 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7517 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7518
7519 if( iItemNum > 0 && activeItem ) {
7520 // print info window title: < item name >
7521 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7522 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7523 activeItem->example->display_name() );
7524 wprintw( w_item_info, " >" );
7525 }
7526
7527 wnoutrefresh( w_items );
7528 wnoutrefresh( w_item_info );
7529
7530 if( filter_type ) {
7531 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7532 }
7533 } );
7534
7535 cata::optional<tripoint> trail_start;
7536 cata::optional<tripoint> trail_end;
7537 bool trail_end_x = false;
7538 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7539 trail_end_x );
7540 add_draw_callback( trail_cb );
7541
7542 do {
7543 if( action == "COMPARE" && activeItem ) {
7544 game_menus::inv::compare( u, active_pos );
7545 } else if( action == "FILTER" ) {
7546 filter_type = item_filter_type::FILTER;
7547 ui.invalidate_ui();
7549 .title( _( "Filter:" ) )
7550 .width( 55 )
7551 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7552 .identifier( "item_filter" )
7553 .max_length( 256 )
7554 .edit( sFilter );
7555 refilter = true;
7556 addcategory = !sort_radius;
7558 filter_type = cata::nullopt;
7559 } else if( action == "RESET_FILTER" ) {
7560 sFilter.clear();
7561 filtered_items = ground_items;
7562 refilter = true;
7564 addcategory = !sort_radius;
7565 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7566 std::vector<iteminfo> vThisItem;
7567 std::vector<iteminfo> vDummy;
7568 activeItem->example->info( true, vThisItem );
7569
7570 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7571 vDummy );
7572 info_data.handle_scrolling = true;
7573
7575 return catacurses::newwin( TERMY, width - 5, point_zero );
7576 }, info_data );
7577 } else if( action == "PRIORITY_INCREASE" ) {
7578 filter_type = item_filter_type::HIGH_PRIORITY;
7579 ui.invalidate_ui();
7581 .title( _( "High Priority:" ) )
7582 .width( 55 )
7584 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7585 .identifier( "list_item_priority" )
7586 .max_length( 256 )
7587 .query_string();
7588 refilter = true;
7589 addcategory = !sort_radius;
7591 filter_type = cata::nullopt;
7592 } else if( action == "PRIORITY_DECREASE" ) {
7593 filter_type = item_filter_type::LOW_PRIORITY;
7594 ui.invalidate_ui();
7596 .title( _( "Low Priority:" ) )
7597 .width( 55 )
7599 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7600 .identifier( "list_item_downvote" )
7601 .max_length( 256 )
7602 .query_string();
7603 refilter = true;
7604 addcategory = !sort_radius;
7606 filter_type = cata::nullopt;
7607 } else if( action == "SORT" ) {
7608 if( sort_radius ) {
7609 sort_radius = false;
7610 addcategory = true;
7611 uistate.list_item_sort = 2; // list is sorted by category
7612 } else {
7613 sort_radius = true;
7614 uistate.list_item_sort = 1; // list is sorted by distance
7615 }
7616 highPEnd = -1;
7617 lowPStart = -1;
7618 iCatSortNum = 0;
7619
7620 mSortCategory.clear();
7621 refilter = true;
7622 } else if( action == "TRAVEL_TO" && activeItem ) {
7623 if( !u.sees( u.pos() + active_pos ) ) {
7624 add_msg( _( "You can't see that destination." ) );
7625 }
7626 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7627 u.get_path_avoid() );
7628 if( route.size() > 1 ) {
7629 route.pop_back();
7630 u.set_destination( route );
7631 break;
7632 } else {
7633 add_msg( m_info, _( "You can't travel there." ) );
7634 }
7635 }
7636 if( uistate.list_item_sort == 1 ) {
7637 ground_items = item_list;
7638 } else if( uistate.list_item_sort == 2 ) {
7639 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7640 }
7641
7642 if( refilter ) {
7643 refilter = false;
7644 filtered_items = filter_item_stacks( ground_items, sFilter );
7645 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7646 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7647 iActive = 0;
7648 page_num = 0;
7649 iItemNum = filtered_items.size();
7650 }
7651
7652 if( addcategory ) {
7653 addcategory = false;
7654 iCatSortNum = 0;
7655 mSortCategory.clear();
7656 if( highPEnd > 0 ) {
7657 mSortCategory[0] = _( "HIGH PRIORITY" );
7658 iCatSortNum++;
7659 }
7660 std::string last_cat_name;
7661 for( int i = std::max( 0, highPEnd );
7662 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7663 const std::string &cat_name = filtered_items[i].example->get_category().name();
7664 if( cat_name != last_cat_name ) {
7665 mSortCategory[i + iCatSortNum++] = cat_name;
7666 last_cat_name = cat_name;
7667 }
7668 }
7669 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7670 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7671 }
7672 if( !mSortCategory[0].empty() ) {
7673 iActive++;
7674 }
7675 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7676 }
7677
7678 if( action == "UP" ) {
7679 do {
7680 iActive--;
7681
7682 } while( !mSortCategory[iActive].empty() );
7683 iScrollPos = 0;
7684 page_num = 0;
7685 if( iActive < 0 ) {
7686 iActive = iItemNum - 1;
7687 }
7688 } else if( action == "DOWN" ) {
7689 do {
7690 iActive++;
7691
7692 } while( !mSortCategory[iActive].empty() );
7693 iScrollPos = 0;
7694 page_num = 0;
7695 if( iActive >= iItemNum ) {
7696 iActive = mSortCategory[0].empty() ? 0 : 1;
7697 }
7698 } else if( action == "RIGHT" ) {
7699 if( !filtered_items.empty() && activeItem ) {
7700 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7701 page_num = activeItem->vIG.size() - 1;
7702 }
7703 }
7704 } else if( action == "LEFT" ) {
7705 page_num = std::max( 0, page_num - 1 );
7706 } else if( action == "PAGE_UP" ) {
7707 iScrollPos--;
7708 } else if( action == "PAGE_DOWN" ) {
7709 iScrollPos++;
7710 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7711 u.view_offset = stored_view_offset;
7713 }
7714
7715 active_pos = tripoint_zero;
7716 activeItem = nullptr;
7717
7718 if( mSortCategory[iActive].empty() ) {
7719 auto iter = filtered_items.begin();
7720 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7721 if( mSortCategory[iNum].empty() ) {
7722 ++iter;
7723 }
7724 }
7725 if( iter != filtered_items.end() ) {
7726 active_pos = iter->vIG[page_num].pos;
7727 activeItem = &( *iter );
7728 }
7729 }
7730
7731 if( activeItem ) {
7732 centerlistview( active_pos, width );
7733 trail_start = u.pos();
7734 trail_end = u.pos() + active_pos;
7735 // Actually accessed from the terrain overlay callback `trail_cb` in the
7736 // call to `ui_manager::redraw`.
7737 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7738 trail_end_x = true;
7739 } else {
7740 u.view_offset = stored_view_offset;
7741 trail_start = trail_end = cata::nullopt;
7742 }
7744
7746
7747 action = ctxt.handle_input();
7748 } while( action != "QUIT" );
7749
7750 u.view_offset = stored_view_offset;
7751 return game::vmenu_ret::QUIT;
7752}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1052
std::string list_item_downvote
Definition: game.h:1053
std::string sFilter
Definition: game.h:1051
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7195
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1103
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4015
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9672
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4438
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3208
uistatedata uistate
Definition: game.cpp:273
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7040
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7263 of file game.cpp.

7264{
7265 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7266 // whole reality bubble
7267 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7268
7269 if( mons.empty() && items.empty() ) {
7270 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7271 return;
7272 }
7273
7274 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7275 const auto att_lhs = lhs->attitude_to( u );
7276 const auto att_rhs = rhs->attitude_to( u );
7277
7278 return att_lhs < att_rhs || ( att_lhs == att_rhs
7279 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7280 } );
7281
7282 // If the current list is empty, switch to the non-empty list
7284 if( items.empty() ) {
7285 uistate.vmenu_show_items = false;
7286 }
7287 } else if( mons.empty() ) {
7289 }
7290
7293 while( true ) {
7294 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7297 } else {
7298 break;
7299 }
7300 }
7301
7302 if( ret == game::vmenu_ret::FIRE ) {
7304 }
7306}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7754
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7308
vmenu_ret
Definition: game.h:790
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:6969
void temp_exit_fullscreen()
Definition: game.cpp:539
void reenter_fullscreen()
Definition: game.cpp:549
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:844
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:206
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:185
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:175
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:170
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:180
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
#define BORDER_COLOR
Definition: output.h:135
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7754 of file game.cpp.

7755{
7756 const int iInfoHeight = 15;
7757 const int width = 45;
7758 int offsetX = 0;
7759 int iMaxRows = 0;
7760
7761 catacurses::window w_monsters;
7762 catacurses::window w_monsters_border;
7763 catacurses::window w_monster_info;
7764 catacurses::window w_monster_info_border;
7765
7766 Creature *cCurMon = nullptr;
7767 tripoint iActivePos;
7768
7769 bool hide_ui = false;
7770
7771 ui_adaptor ui;
7772 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7773 if( hide_ui ) {
7774 ui.position( point_zero, point_zero );
7775 } else {
7776 offsetX = TERMX - width;
7777 iMaxRows = TERMY - iInfoHeight - 1;
7778
7779 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
7780 1 ) );
7781 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
7782 0 ) );
7783 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
7784 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
7785 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
7786 TERMY - iInfoHeight ) );
7787
7788 if( cCurMon ) {
7789 centerlistview( iActivePos, width );
7790 }
7791
7792 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7793 }
7794 } );
7795 ui.mark_resize();
7796
7797 const int max_gun_range = u.weapon.gun_range( &u );
7798
7799 const tripoint stored_view_offset = u.view_offset;
7801
7802 int iActive = 0; // monster index that we're looking at
7803
7804 std::string action;
7805 input_context ctxt( "LIST_MONSTERS" );
7806 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7807 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7808 ctxt.register_action( "NEXT_TAB" );
7809 ctxt.register_action( "PREV_TAB" );
7810 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
7811 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
7812 ctxt.register_action( "QUIT" );
7813 if( bVMonsterLookFire ) {
7814 ctxt.register_action( "look" );
7815 ctxt.register_action( "fire" );
7816 }
7817 ctxt.register_action( "HELP_KEYBINDINGS" );
7818
7819 // first integer is the row the attitude category string is printed in the menu
7820 std::map<int, Creature::Attitude> mSortCategory;
7821
7822 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
7823 const auto attitude = monster_list[i]->attitude_to( u );
7824 if( attitude != last_attitude ) {
7825 mSortCategory[i + mSortCategory.size()] = attitude;
7826 last_attitude = attitude;
7827 }
7828 }
7829
7830 ui.on_redraw( [&]( const ui_adaptor & ) {
7831 if( !hide_ui ) {
7832 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
7833 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7834 true );
7835
7836 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
7837 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
7838
7839 if( monster_list.empty() ) {
7840 werase( w_monsters );
7841 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
7842 _( "You don't see any monsters around you!" ) );
7843 } else {
7844 werase( w_monsters );
7845
7846 const int iNumMonster = monster_list.size();
7847 const int iMenuSize = monster_list.size() + mSortCategory.size();
7848
7849 const int numw = iNumMonster > 999 ? 4 :
7850 iNumMonster > 99 ? 3 :
7851 iNumMonster > 9 ? 2 : 1;
7852
7853 // given the currently selected monster iActive. get the selected row
7854 int iSelPos = iActive;
7855 for( auto &ia : mSortCategory ) {
7856 int index = ia.first;
7857 if( index <= iSelPos ) {
7858 ++iSelPos;
7859 } else {
7860 break;
7861 }
7862 }
7863 int iStartPos = 0;
7864 // use selected row get the start row
7865 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
7866
7867 // get first visible monster and category
7868 int iCurMon = iStartPos;
7869 auto CatSortIter = mSortCategory.cbegin();
7870 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
7871 ++CatSortIter;
7872 --iCurMon;
7873 }
7874
7875 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
7876 for( int y = 0; y < endY; ++y ) {
7877 if( CatSortIter != mSortCategory.cend() ) {
7878 const int iCurPos = iStartPos + y;
7879 const int iCatPos = CatSortIter->first;
7880 if( iCurPos == iCatPos ) {
7881 const std::string cat_name = Creature::get_attitude_ui_data(
7882 CatSortIter->second ).first.translated();
7883 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
7884 ++CatSortIter;
7885 continue;
7886 }
7887 }
7888 // select current monster
7889 const auto critter = monster_list[iCurMon];
7890 const bool selected = iCurMon == iActive;
7891 ++iCurMon;
7892 if( critter->sees( g->u ) ) {
7893 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
7894 }
7895 bool is_npc = false;
7896 const monster *m = dynamic_cast<monster *>( critter );
7897 const npc *p = dynamic_cast<npc *>( critter );
7898 nc_color name_color = critter->basic_symbol_color();
7899
7900 if( selected ) {
7901 name_color = hilite( name_color );
7902 }
7903
7904 if( m != nullptr ) {
7905 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
7906 } else {
7907 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
7908 is_npc = true;
7909 }
7910
7911 if( selected && !get_safemode().empty() ) {
7912 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
7913
7914 std::string sSafemode;
7915 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
7916 sSafemode = _( "<R>emove from safemode Blacklist" );
7917 } else {
7918 sSafemode = _( "<A>dd to safemode Blacklist" );
7919 }
7920
7921 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
7922 c_white, c_light_green, sSafemode );
7923 }
7924
7926 std::string sText;
7927
7928 if( m != nullptr ) {
7929 m->get_HP_Bar( color, sText );
7930 } else {
7931 std::tie( sText, color ) =
7932 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
7933 }
7934 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
7935
7936 if( m != nullptr ) {
7937 const auto att = m->get_attitude();
7938 sText = att.first;
7939 color = att.second;
7940 } else if( p != nullptr ) {
7941 sText = npc_attitude_name( p->get_attitude() );
7942 color = p->symbol_color();
7943 }
7944 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
7945
7946 const int mon_dist = rl_dist( u.pos(), critter->pos() );
7947 const int numd = mon_dist > 999 ? 4 :
7948 mon_dist > 99 ? 3 :
7949 mon_dist > 9 ? 2 : 1;
7950
7951 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
7952 selected ? c_light_green : c_light_gray,
7953 "%*d %s",
7954 numd, mon_dist,
7955 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
7956 }
7957
7958 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
7959 iActive + 1 );
7960 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
7961
7962 werase( w_monster_info );
7963 if( cCurMon ) {
7964 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
7965 }
7966
7967 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7968 true );
7969
7970 if( bVMonsterLookFire ) {
7971 mvwprintw( w_monster_info_border, point_east, "< " );
7972 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
7973 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
7974
7975 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
7976 wprintw( w_monster_info_border, " " );
7977 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
7978 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
7979 }
7980 wprintw( w_monster_info_border, " >" );
7981 }
7982
7983 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
7984 point_south );
7985 }
7986
7987 wnoutrefresh( w_monsters_border );
7988 wnoutrefresh( w_monster_info_border );
7989 wnoutrefresh( w_monsters );
7990 wnoutrefresh( w_monster_info );
7991 }
7992 } );
7993
7994 cata::optional<tripoint> trail_start;
7995 cata::optional<tripoint> trail_end;
7996 bool trail_end_x = false;
7997 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7998 trail_end_x );
7999 add_draw_callback( trail_cb );
8000
8001 do {
8002 if( action == "UP" ) {
8003 iActive--;
8004 if( iActive < 0 ) {
8005 if( monster_list.empty() ) {
8006 iActive = 0;
8007 } else {
8008 iActive = static_cast<int>( monster_list.size() ) - 1;
8009 }
8010 }
8011 } else if( action == "DOWN" ) {
8012 iActive++;
8013 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8014 iActive = 0;
8015 }
8016 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8017 u.view_offset = stored_view_offset;
8019 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8020 const auto m = dynamic_cast<monster *>( cCurMon );
8021 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8022
8023 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8025 }
8026 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8027 if( !get_safemode().empty() ) {
8028 const auto m = dynamic_cast<monster *>( cCurMon );
8029 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8030
8031 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8033 }
8034 } else if( action == "look" ) {
8035 hide_ui = true;
8036 ui.mark_resize();
8037 look_around();
8038 hide_ui = false;
8039 ui.mark_resize();
8040 } else if( action == "fire" ) {
8041 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8042 u.last_target = shared_from( *cCurMon );
8044 u.view_offset = stored_view_offset;
8045 return game::vmenu_ret::FIRE;
8046 }
8047 }
8048
8049 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8050 cCurMon = monster_list[iActive];
8051 iActivePos = cCurMon->pos() - u.pos();
8052 centerlistview( iActivePos, width );
8053 trail_start = u.pos();
8054 trail_end = cCurMon->pos();
8055 // Actually accessed from the terrain overlay callback `trail_cb` in the
8056 // call to `ui_manager::redraw`.
8057 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8058 trail_end_x = false;
8059 } else {
8060 cCurMon = nullptr;
8061 iActivePos = tripoint_zero;
8062 u.view_offset = stored_view_offset;
8063 trail_start = trail_end = cata::nullopt;
8064 }
8066
8068
8069 action = ctxt.handle_input();
8070 } while( action != "QUIT" );
8071
8072 u.view_offset = stored_view_offset;
8073
8074 return game::vmenu_ret::QUIT;
8075}
double recoil
Definition: character.h:561
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6108
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1860
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4663
bool bVMonsterLookFire
Definition: game.h:1056
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7195
npc_attitude get_attitude() const
Definition: npc.cpp:3139
weak_ptr_fast< Creature > last_target
Definition: player.h:607
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2545
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2616 of file game.cpp.

2617{
2620 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2623
2624 using namespace std::placeholders;
2625
2626 const std::string worldpath = get_world_base_save_path() + "/";
2627 const std::string playerpath = worldpath + name.base_path();
2628
2629 // Now load up the master game data; factions (and more?)
2630 load_master();
2631 u = avatar();
2632 u.name = name.player_name();
2633 // This should be initialized more globally (in player/Character constructor)
2635 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2636 return false;
2637 }
2638
2640
2642
2643 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2644 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2645
2646#if defined(__ANDROID__)
2647 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2648 std::bind( &game::load_shortcuts, this, _1 ) );
2649#endif
2650
2651 // Now that the player's worn items are updated, their sight limits need to be
2652 // recalculated. (This would be cleaner if u.worn were private.)
2654
2655 if( !gamemode ) {
2656 gamemode = std::make_unique<special_game>();
2657 }
2658
2659 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2660 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2661
2662 init_autosave();
2663 get_auto_pickup().load_character(); // Load character auto pickup rules
2664 get_auto_notes_settings().load(); // Load character auto notes settings
2665 get_safemode().load_character(); // Load character safemode rules
2666 zone_manager::get_manager().load_zones(); // Load character world zones
2667 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2668 JsonIn jsin( stream );
2669 uistate.deserialize( jsin );
2670 } );
2671 reload_npcs();
2676 update_map( u );
2677 for( auto &e : u.inv_dump() ) {
2678 e->set_owner( g->u );
2679 }
2680 // legacy, needs to be here as we access the map.
2681 if( !u.getID().is_valid() ) {
2682 // player does not have a real id, so assign a new one,
2683 u.setID( assign_npc_id() );
2684 // The vehicle stores the IDs of the boarded players, so update it, too.
2685 if( u.in_vehicle ) {
2687 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2688 vp->part().passenger_id = u.getID();
2689 }
2690 }
2691 }
2692
2693 // populate calendar caches now, after active world is set, but before we do
2694 // anything else, to ensure they pick up the correct value from the save's
2695 // worldoptions
2696 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2697 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2698
2699 u.reset();
2700
2701 return true;
2702}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:466
std::vector< item * > inv_dump()
Definition: character.cpp:8957
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1703
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3622
Definition: json.h:177
Definition: avatar.h:54
void load_map_memory()
Definition: avatar.cpp:134
bool is_valid() const
Definition: character_id.h:19
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1981
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:961
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2039
void load_master()
Definition: game.cpp:2585
void validate_mounted_npcs()
Definition: game.cpp:1996
character_id assign_npc_id()
Definition: game.cpp:3702
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11291
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2015
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:276
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2592 of file game.cpp.

2593{
2594 world_generator->init();
2595 const WORLDPTR wptr = world_generator->get_world( world );
2596 if( !wptr ) {
2597 return false;
2598 }
2599 if( wptr->world_saves.empty() ) {
2600 debugmsg( "world '%s' contains no saves", world );
2601 return false;
2602 }
2603
2604 try {
2605 world_generator->set_active_world( wptr );
2606 g->setup();
2607 g->load( wptr->world_saves.front() );
2608 } catch( const std::exception &err ) {
2609 debugmsg( "cannot load world '%s': %s", world, err.what() );
2610 return false;
2611 }
2612
2613 return true;
2614}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 439 of file game.cpp.

440{
441 // core data can be loaded only once and must be first
442 // anyway.
444
446}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:524
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 448 of file game.cpp.

449{
451}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:454

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Definition at line 635 of file game.cpp.

636{
637 // TODO: fix point types
638 load_map( tripoint_abs_sm( pos_sm ) );
639}
void load_map(const tripoint &pos_sm)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:635
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm)

Definition at line 641 of file game.cpp.

642{
643 m.load( pos_sm, true );
644 grid_tracker_ptr->load( m );
645}
void load(const tripoint &w, bool update_vehicles)
Load submaps into grid.
Definition: map.cpp:6591

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2585 of file game.cpp.

2586{
2587 using namespace std::placeholders;
2588 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2589 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2590}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1188
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 899 of file game.cpp.

900{
901 const int radius = HALF_MAPSIZE - 1;
902 // uses submap coordinates
903 std::vector<shared_ptr_fast<npc>> just_added;
904 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
905 const character_id &id = temp->getID();
906 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
907 [id]( const shared_ptr_fast<npc> &n ) {
908 return n->getID() == id;
909 } );
910 if( found != active_npc.end() ) {
911 continue;
912 }
913 if( temp->is_active() ) {
914 continue;
915 }
916 if( temp->has_companion_mission() ) {
917 continue;
918 }
919
920 const tripoint sm_loc = temp->global_sm_location();
921 // NPCs who are out of bounds before placement would be pushed into bounds
922 // This can cause NPCs to teleport around, so we don't want that
923 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
924 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
925 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
926 continue;
927 }
928
929 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
930 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
931 temp->place_on_map();
932 if( !m.inbounds( temp->pos() ) ) {
933 continue;
934 }
935 // In the rare case the npc was marked for death while
936 // it was on the overmap. Kill it.
937 if( temp->marked_for_death ) {
938 temp->die( nullptr );
939 } else {
940 active_npc.push_back( temp );
941 just_added.push_back( temp );
942 }
943 }
944
945 for( const auto &npc : just_added ) {
946 npc->on_load();
947 }
948
949 npcs_dirty = false;
950}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2658
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2740 of file game.cpp.

2741{
2742 ui.new_context( msg );
2743 std::vector<mod_id> missing;
2744 std::vector<mod_id> available;
2745
2746 for( const mod_id &e : packs ) {
2747 if( e.is_valid() ) {
2748 available.emplace_back( e );
2749 ui.add_entry( e->name() );
2750 } else {
2751 missing.push_back( e );
2752 }
2753 }
2754
2755 ui.show();
2756 for( const auto &e : available ) {
2757 const MOD_INFORMATION &mod = *e;
2758 load_data_from_dir( mod.path, mod.ident.str(), ui );
2759 ui.proceed();
2760 }
2761
2762 for( const auto &e : missing ) {
2763 debugmsg( "unknown content %s", e.c_str() );
2764 }
2765
2766 return missing.empty();
2767}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 325 of file game.cpp.

326{
327 // UI stuff, not mod-specific per definition
328 inp_mngr.init(); // Load input config JSON
329 // Init mappings for loading the json stuff
331 fullscreen = false;
332 was_fullscreen = false;
333 show_panel_adm = false;
335
336 // These functions do not load stuff from json.
337 // The content they load/initialize is hardcoded into the program.
338 // Therefore they can be loaded here.
339 // If this changes (if they load data from json), they have to
340 // be moved to game::load_mod or game::load_core_data
341
344}
bool was_fullscreen
Definition: game.h:1038
bool fullscreen
Definition: game.h:1037
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2310
void load_global()

References fullscreen, get_auto_pickup(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2704 of file game.cpp.

2705{
2706 auto &mods = world_generator->active_world->active_mod_order;
2707
2708 // remove any duplicates whilst preserving order (fixes #19385)
2709 std::set<mod_id> found;
2710 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2711 if( found.count( e ) ) {
2712 return true;
2713 } else {
2714 found.insert( e );
2715 return false;
2716 }
2717 } ), mods.end() );
2718
2719 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2720 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2721 return e->core;
2722} ) ) {
2723 mods.insert( mods.begin(), mod_id( "dda" ) );
2724 }
2725
2727 // this code does not care about mod dependencies,
2728 // it assumes that those dependencies are static and
2729 // are resolved during the creation of the world.
2730 // That means world->active_mod_order contains a list
2731 // of mods in the correct order.
2732 load_packs( _( "Loading files" ), mods, ui );
2733
2734 // Load additional mods from that world-specific folder
2735 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2736
2738}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( )

Definition at line 6619 of file game.cpp.

6620{
6622 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6623 false );
6624 return result.position;
6625}

References center, look_around(), Character::pos(), u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6627 of file game.cpp.

6630{
6631 bVMonsterLookFire = false;
6632 // TODO: Make this `true`
6633 const bool allow_zlev_move = m.has_zlevels() && get_option<bool>( "FOV_3D" );
6634
6636
6637 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6638 int &lx = lp.x;
6639 int &ly = lp.y;
6640 int &lz = lp.z;
6641
6642 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6643 bool fast_scroll = false;
6644
6645 std::unique_ptr<ui_adaptor> ui;
6646 catacurses::window w_info;
6647 if( show_window ) {
6648 ui = std::make_unique<ui_adaptor>();
6649 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6650 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6652
6653 // If particularly small, base height on panel width irrespective of other elements.
6654 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6655 if( height < panel_width / 2 ) {
6656 height = panel_width / 2;
6657 }
6658
6659 int la_y = 0;
6660 int la_x = TERMX - panel_width;
6661 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6662 if( position == "left" ) {
6663 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6665 } else {
6666 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6667 }
6668 }
6669 int la_h = height;
6670 int la_w = panel_width;
6671 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6672
6673 ui.position_from_window( w_info );
6674 } );
6675 ui->mark_resize();
6676 }
6677
6678 std::string action;
6679 input_context ctxt( "LOOK" );
6680 ctxt.set_iso( true );
6681 ctxt.register_directions();
6682 ctxt.register_action( "COORDINATE" );
6683 ctxt.register_action( "LEVEL_UP" );
6684 ctxt.register_action( "LEVEL_DOWN" );
6685 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6686 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6687 ctxt.register_action( "SELECT" );
6688 if( peeking ) {
6689 ctxt.register_action( "throw_blind" );
6690 }
6691 if( !select_zone ) {
6692 ctxt.register_action( "TRAVEL_TO" );
6693 ctxt.register_action( "LIST_ITEMS" );
6694 }
6695 ctxt.register_action( "MOUSE_MOVE" );
6696 ctxt.register_action( "CENTER" );
6697
6698 ctxt.register_action( "debug_scent" );
6699 ctxt.register_action( "debug_scent_type" );
6700 ctxt.register_action( "debug_temp" );
6701 ctxt.register_action( "debug_visibility" );
6702 ctxt.register_action( "debug_lighting" );
6703 ctxt.register_action( "debug_radiation" );
6704 ctxt.register_action( "debug_submap_grid" );
6705 ctxt.register_action( "debug_hour_timer" );
6706 ctxt.register_action( "CONFIRM" );
6707 ctxt.register_action( "QUIT" );
6708 ctxt.register_action( "HELP_KEYBINDINGS" );
6709 if( use_tiles ) {
6710 ctxt.register_action( "zoom_out" );
6711 ctxt.register_action( "zoom_in" );
6712 }
6713#if defined(TILES)
6714 ctxt.register_action( "toggle_pixel_minimap" );
6715#endif // TILES
6716
6717 const int old_levz = get_levz();
6718 const int min_levz = std::max( old_levz - fov_3d_z_range, -OVERMAP_DEPTH );
6719 const int max_levz = std::min( old_levz + fov_3d_z_range, OVERMAP_HEIGHT );
6720
6721 m.update_visibility_cache( old_levz );
6723
6724 bool blink = true;
6726
6727 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6728
6729 if( show_window && ui ) {
6730 ui->on_redraw( [&]( const ui_adaptor & ) {
6731 werase( w_info );
6732 draw_border( w_info );
6733
6734 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6735
6736 std::string extended_descr_text = string_format( _( "%s - %s" ),
6737 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6738 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6739 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6740 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6741 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6742#if defined(TILES)
6743 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6744 ctxt.get_desc( "toggle_pixel_minimap" ),
6745 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6746#endif // TILES
6747
6748 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6749 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6750 fast_scroll_text );
6751#if defined(TILES)
6752 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6753 pixel_minimap_text );
6754#endif // TILES
6755
6756 int first_line = 1;
6757 const int last_line = getmaxy( w_info ) - 3;
6758 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6759
6760 wnoutrefresh( w_info );
6761 } );
6762 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6763 draw_look_around_cursor( lp, cache );
6764 } );
6765 add_draw_callback( ter_indicator_cb );
6766 }
6767
6768 cata::optional<tripoint> zone_start;
6769 cata::optional<tripoint> zone_end;
6770 bool zone_blink = false;
6771 bool zone_cursor = true;
6772 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
6773 zone_cursor, is_moving_zone );
6774 add_draw_callback( zone_cb );
6775
6776 is_looking = true;
6777 const tripoint prev_offset = u.view_offset;
6778#if defined(TILES)
6779 const int prev_tileset_zoom = tileset_zoom;
6780 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
6781 get_zoom() != 4 ) {
6782 zoom_out();
6783 }
6785#endif
6786 do {
6787 u.view_offset = center - u.pos();
6788 if( select_zone ) {
6789 if( has_first_point ) {
6790 zone_start = start_point;
6791 zone_end = lp;
6792 } else {
6793 zone_start = lp;
6794 zone_end = cata::nullopt;
6795 }
6796 // Actually accessed from the terrain overlay callback `zone_cb` in the
6797 // call to `ui_manager::redraw`.
6798 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6799 zone_blink = blink;
6800 }
6801
6802 if( is_moving_zone ) {
6803 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
6804 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
6805 // Actually accessed from the terrain overlay callback `zone_cb` in the
6806 // call to `ui_manager::redraw`.
6807 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6808 zone_blink = blink;
6809 }
6812 if( ( select_zone && has_first_point ) || is_moving_zone ) {
6813 ctxt.set_timeout( BLINK_SPEED );
6814 }
6815
6816 //Wait for input
6817 // only specify a timeout here if "EDGE_SCROLL" is enabled
6818 // otherwise use the previously set timeout
6819 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
6820 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
6821 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
6822 if( edge_scrolling ) {
6823 action = ctxt.handle_input( scroll_timeout );
6824 } else {
6825 action = ctxt.handle_input();
6826 }
6827 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
6828 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
6829 blink = true; // Always draw blink symbols when moving cursor
6830 } else if( action == "TIMEOUT" ) {
6831 blink = !blink;
6832 }
6833 if( action == "LIST_ITEMS" ) {
6835 } else if( action == "TOGGLE_FAST_SCROLL" ) {
6836 fast_scroll = !fast_scroll;
6837 } else if( action == "toggle_pixel_minimap" ) {
6839
6840 if( show_window && ui ) {
6841 ui->mark_resize();
6842 }
6843 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
6844 if( !allow_zlev_move ) {
6845 continue;
6846 }
6847
6848 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
6849 lz = clamp( lz + dz, min_levz, max_levz );
6850 center.z = clamp( center.z + dz, min_levz, max_levz );
6851
6852 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
6853 u.view_offset.z = center.z - u.posz();
6855 } else if( action == "TRAVEL_TO" ) {
6856 if( !u.sees( lp ) ) {
6857 add_msg( _( "You can't see that destination." ) );
6858 continue;
6859 }
6860
6861 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
6862 if( route.size() > 1 ) {
6863 route.pop_back();
6864 u.set_destination( route );
6865 } else {
6866 add_msg( m_info, _( "You can't travel there." ) );
6867 continue;
6868 }
6869 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
6871 display_scent();
6872 }
6873 } else if( action == "debug_temp" ) {
6876 }
6877 } else if( action == "debug_lighting" ) {
6880 }
6881 } else if( action == "debug_transparency" ) {
6884 }
6885 } else if( action == "debug_radiation" ) {
6888 }
6889 } else if( action == "debug_submap_grid" ) {
6890 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
6891 } else if( action == "debug_hour_timer" ) {
6893 } else if( action == "EXTENDED_DESCRIPTION" ) {
6895 } else if( action == "CENTER" ) {
6896 center = u.pos();
6897 lp = u.pos();
6898 u.view_offset.z = 0;
6899 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
6900 // This block is structured this way so that edge scroll can work
6901 // whether the mouse is moving at the edge or simply stationary
6902 // at the edge. But even if edge scroll isn't in play, there's
6903 // other things for us to do here.
6904
6905 if( edge_scrolling ) {
6906 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
6907 } else if( action == "MOUSE_MOVE" ) {
6908 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
6909 if( mouse_pos ) {
6910 lx = mouse_pos->x;
6911 ly = mouse_pos->y;
6912 }
6913 }
6914 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
6915 if( fast_scroll ) {
6916 vec->x *= soffset;
6917 vec->y *= soffset;
6918 }
6919
6920 lx = lx + vec->x;
6921 ly = ly + vec->y;
6922 center.x = center.x + vec->x;
6923 center.y = center.y + vec->y;
6924 } else if( action == "throw_blind" ) {
6925 result.peek_action = PA_BLIND_THROW;
6926 } else if( action == "zoom_in" ) {
6927 center.x = lp.x;
6928 center.y = lp.y;
6929 zoom_in();
6931 } else if( action == "zoom_out" ) {
6932 center.x = lp.x;
6933 center.y = lp.y;
6934 zoom_out();
6936 }
6937 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
6938 action != "throw_blind" );
6939
6940 if( m.has_zlevels() && center.z != old_levz ) {
6941 m.invalidate_map_cache( old_levz );
6942 m.build_map_cache( old_levz );
6943 u.view_offset.z = 0;
6944 }
6945
6946 ctxt.reset_timeout();
6947 u.view_offset = prev_offset;
6948 zone_cb = nullptr;
6949 is_looking = false;
6950
6952 bVMonsterLookFire = true;
6953
6954 if( action == "CONFIRM" || action == "SELECT" ) {
6955 result.position = is_moving_zone ? zone_start : lp;
6956 }
6957
6958#if defined(TILES)
6959 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
6960 // Reset the tileset zoom to the previous value
6961 set_zoom( prev_tileset_zoom );
6963 }
6964#endif
6965
6966 return result;
6967}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2166
void set_zoom(int level)
Definition: game.cpp:7118
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5732
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6606
int get_zoom() const
Definition: game.cpp:7130
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5627
void invalidate_map_cache(const int zlev)
Definition: map.h:471
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2278
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3161
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5725 of file game.cpp.

5726{
5727 editmap edit;
5728 return edit.edit();
5729}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3118 of file game.cpp.

3119{
3121 if( ui ) {
3122 ui->mark_resize();
3123 }
3124}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 2860 of file game.cpp.

2861{
2862 return *memorial_logger_ptr;
2863}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 3809 of file game.cpp.

3810{
3811 const monster_visible_info &mon_visible = u.get_mon_visible();
3812 const auto &unique_types = mon_visible.unique_types;
3813 const auto &unique_mons = mon_visible.unique_mons;
3814 const auto &dangerous = mon_visible.dangerous;
3815
3816 const int width = getmaxx( w ) - 2 * hor_padding;
3817 const int maxheight = getmaxy( w );
3818
3819 const int startrow = 0;
3820
3821 // Print the direction headings
3822 // Reminder:
3823 // 7 0 1 unique_types uses these indices;
3824 // 6 8 2 0-7 are provide by direction_from()
3825 // 5 4 3 8 is used for local monsters (for when we explain them below)
3826
3827 const std::array<std::string, 8> dir_labels = {{
3828 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
3829 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
3830 }
3831 };
3832 std::array<int, 8> widths;
3833 for( int i = 0; i < 8; i++ ) {
3834 widths[i] = utf8_width( dir_labels[i] );
3835 }
3836 std::array<int, 8> xcoords;
3837 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
3838 xcoords[0] = xcoords[4] = width / 3;
3839 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
3840 xcoords[5] = xcoords[6] = xcoords[7] = 0;
3841 //for the alignment of the 1,2,3 rows on the right edge
3842 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
3843 for( int i = 0; i < 8; i++ ) {
3844 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
3845 : ( dangerous[i] ? c_light_red : c_light_gray );
3846 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
3847 }
3848
3849 // Print the symbols of all monsters in all directions.
3850 for( int i = 0; i < 8; i++ ) {
3851 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
3852
3853 // The list of symbols needs a space on each end.
3854 int symroom = ( width / 3 ) - widths[i] - 2;
3855 const int typeshere_npc = unique_types[i].size();
3856 const int typeshere_mon = unique_mons[i].size();
3857 const int typeshere = typeshere_mon + typeshere_npc;
3858 for( int j = 0; j < typeshere && j < symroom; j++ ) {
3859 nc_color c;
3860 std::string sym;
3861 if( symroom < typeshere && j == symroom - 1 ) {
3862 // We've run out of room!
3863 c = c_white;
3864 sym = "+";
3865 } else if( j < typeshere_npc ) {
3866 switch( unique_types[i][j]->get_attitude() ) {
3867 case NPCATT_KILL:
3868 c = c_red;
3869 break;
3870 case NPCATT_FOLLOW:
3871 c = c_light_green;
3872 break;
3873 default:
3874 c = c_pink;
3875 break;
3876 }
3877 sym = "@";
3878 } else {
3879 const mtype &mt = *unique_mons[i][j - typeshere_npc];
3880 c = mt.color;
3881 sym = mt.sym;
3882 }
3883 mvwprintz( w, pr, c, sym );
3884
3885 pr.x++;
3886 }
3887 }
3888
3889 // Now we print their full names!
3890
3891 std::set<const mtype *> listed_mons;
3892
3893 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
3894 // is blank.
3895 point pr( hor_padding, 4 + startrow );
3896
3897 // Print monster names, starting with those at location 8 (nearby).
3898 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
3899 // Separate names by some number of spaces (more for local monsters).
3900 int namesep = ( j == 8 ? 2 : 1 );
3901 for( const mtype *type : unique_mons[j] ) {
3902 if( pr.y >= maxheight ) {
3903 // no space to print to anyway
3904 break;
3905 }
3906 if( listed_mons.count( type ) > 0 ) {
3907 // this type is already printed.
3908 continue;
3909 }
3910 listed_mons.insert( type );
3911
3912 const mtype &mt = *type;
3913 const std::string name = mt.nname();
3914
3915 // Move to the next row if necessary. (The +2 is for the "Z ").
3916 if( pr.x + 2 + utf8_width( name ) >= width ) {
3917 pr.y++;
3918 pr.x = hor_padding;
3919 }
3920
3921 if( pr.y < maxheight ) { // Don't print if we've overflowed
3922 mvwprintz( w, pr, mt.color, mt.sym );
3923 pr.x += 2; // symbol and space
3924 nc_color danger = c_dark_gray;
3925 if( mt.difficulty >= 30 ) {
3926 danger = c_red;
3927 } else if( mt.difficulty >= 16 ) {
3928 danger = c_light_red;
3929 } else if( mt.difficulty >= 8 ) {
3930 danger = c_white;
3931 } else if( mt.agro > 0 ) {
3932 danger = c_light_gray;
3933 }
3934 mvwprintz( w, pr, danger, name );
3935 pr.x += utf8_width( name ) + namesep;
3936 }
3937 }
3938 }
3939}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< const mtype * > unique_mons[9]
Definition: avatar.h:47
bool dangerous[8]
Definition: avatar.h:50
std::vector< npc * > unique_types[9]
Definition: avatar.h:46
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:253
nc_color color
Definition: mtype.h:258
int difficulty
Definition: mtype.h:264
int agro
e.g.
Definition: mtype.h:269

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 3941 of file game.cpp.

3942{
3943 int newseen = 0;
3944 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
3945 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
3946 safe_proxy_dist;
3947
3948 monster_visible_info &mon_visible = u.get_mon_visible();
3949 auto &new_seen_mon = mon_visible.new_seen_mon;
3950 auto &unique_types = mon_visible.unique_types;
3951 auto &unique_mons = mon_visible.unique_mons;
3952 auto &dangerous = mon_visible.dangerous;
3953
3954 // 7 0 1 unique_types uses these indices;
3955 // 6 8 2 0-7 are provide by direction_from()
3956 // 5 4 3 8 is used for local monsters (for when we explain them below)
3957 for( auto &t : unique_types ) {
3958 t.clear();
3959 }
3960 for( auto &m : unique_mons ) {
3961 m.clear();
3962 }
3963 std::fill( dangerous, dangerous + 8, false );
3964
3965 const tripoint view = u.pos() + u.view_offset;
3966 new_seen_mon.clear();
3967
3968 // TODO: no reason to have it static here
3969 static time_point previous_turn = calendar::start_of_cataclysm;
3970 const time_duration sm_ignored_time = time_duration::from_turns(
3971 get_option<int>( "SAFEMODEIGNORETURNS" ) );
3972
3974 monster *m = dynamic_cast<monster *>( c );
3975 npc *p = dynamic_cast<npc *>( c );
3976 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
3977 const int mx = POSX + ( c->posx() - view.x );
3978 const int my = POSY + ( c->posy() - view.y );
3979 int index = 8;
3980 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
3981 // for compatibility with old code, see diagram below, it explains the values for index,
3982 // also might need revisiting one z-levels are in.
3983 switch( dir_to_mon ) {
3987 index = 7;
3988 break;
3990 case direction::NORTH:
3992 index = 0;
3993 break;
3997 index = 1;
3998 break;
4000 case direction::WEST:
4002 index = 6;
4003 break;
4005 case direction::CENTER:
4007 index = 8;
4008 break;
4010 case direction::EAST:
4012 index = 2;
4013 break;
4017 index = 5;
4018 break;
4020 case direction::SOUTH:
4022 index = 4;
4023 break;
4027 index = 3;
4028 break;
4029 }
4030 }
4031
4032 rule_state safemode_state = RULE_NONE;
4033 const bool safemode_empty = get_safemode().empty();
4034
4035 if( m != nullptr ) {
4036 //Safemode monster check
4037 monster &critter = *m;
4038
4039 const monster_attitude matt = critter.attitude( &u );
4040 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4041 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4042
4043 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4044 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4045 if( index < 8 && critter.sees( g->u ) ) {
4046 dangerous[index] = true;
4047 }
4048
4049 if( !safemode_empty || mon_dist <= iProxyDist ) {
4050 bool passmon = false;
4051 if( critter.ignoring > 0 ) {
4052 if( safe_mode != SAFE_MODE_ON ) {
4053 critter.ignoring = 0;
4054 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4055 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4056 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4057 passmon = true;
4058 }
4059 critter.lastseen_turn = calendar::turn;
4060 }
4061
4062 if( !passmon ) {
4063 newseen++;
4064 new_seen_mon.push_back( shared_from( critter ) );
4065 }
4066 }
4067 }
4068
4069 std::vector<const mtype *> &vec = unique_mons[index];
4070 if( std::find( vec.begin(), vec.end(), critter.type ) == vec.end() ) {
4071 vec.push_back( critter.type );
4072 }
4073 } else if( p != nullptr ) {
4074 //Safe mode NPC check
4075
4076 const int npc_dist = rl_dist( u.pos(), p->pos() );
4077 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4078 npc_dist );
4079
4080 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4081 p->get_attitude() == NPCATT_KILL ) ) {
4082 if( !safemode_empty || npc_dist <= iProxyDist ) {
4083 newseen++;
4084 }
4085 }
4086 unique_types[index].push_back( p );
4087 }
4088 }
4089
4090 if( newseen > mostseen ) {
4091 if( newseen - mostseen == 1 ) {
4092 if( !new_seen_mon.empty() ) {
4093 monster &critter = *new_seen_mon.back();
4095 string_format( _( "%s spotted!" ), critter.name() ) );
4096 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4097 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4099 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4100 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4101 // Triffids present. We ain't got TIME to adrenaline comedown!
4102 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4103 u.mod_pain( 3 ); // Does take it out of you, though
4104 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4105 }
4106 }
4107 } else {
4108 //Hostile NPC
4110 _( "Hostile survivor spotted!" ) );
4111 }
4112 } else {
4114 }
4116 if( safe_mode == SAFE_MODE_ON ) {
4118 }
4119 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4120 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4121 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4122 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4124 add_msg( m_info, _( "Safe mode ON!" ) );
4125 }
4126 }
4127
4128 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4130 }
4131
4132 previous_turn = calendar::turn;
4133 mostseen = newseen;
4134}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1250
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1793
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1066
cata::optional< time_point > lastseen_turn
Definition: monster.h:508
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2077
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:275
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:54
@ MATT_FOLLOW
Definition: monster.h:60
@ MATT_ATTACK
Definition: monster.h:61
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), detail::find(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4171 of file game.cpp.

4172{
4173 cleanup_dead();
4174
4175 for( monster &critter : all_monsters() ) {
4176 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4177 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4178 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4179 critter.pos().to_string(), m.tername( critter.pos() ) );
4180 dbg( DL::Error ) << msg;
4181 add_msg( m_debug, msg );
4182 bool okay = false;
4183 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4184 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4185 critter.setpos( dest );
4186 okay = true;
4187 break;
4188 }
4189 }
4190 if( !okay ) {
4191 // die of "natural" cause (overpopulation is natural)
4192 critter.die( nullptr );
4193 }
4194 }
4195
4196 if( !critter.is_dead() ) {
4197 critter.process_items();
4198 }
4199
4200 if( !critter.is_dead() ) {
4201 critter.process_turn();
4202 }
4203
4204 m.creature_in_field( critter );
4205 if( calendar::once_every( 1_days ) ) {
4206 if( critter.has_flag( MF_MILKABLE ) ) {
4207 critter.refill_udders();
4208 }
4209 critter.try_reproduce();
4210 }
4211 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4212 critter.made_footstep = false;
4213 // Controlled critters don't make their own plans
4214 if( !critter.has_effect( effect_ai_controlled ) ) {
4215 // Formulate a path to follow
4216 critter.plan();
4217 }
4218 critter.move(); // Move one square, possibly hit u
4219 critter.process_triggers();
4220 m.creature_in_field( critter );
4221 }
4222
4223 if( !critter.is_dead() &&
4224 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4225 u.get_power_level() >= 25_kJ &&
4226 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4227 !critter.is_hallucination() ) {
4228 u.mod_power_level( -25_kJ );
4229 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4231 _( "Your motion alarm goes off!" ) );
4232 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4233 u.wake_up();
4234 }
4235 }
4236 }
4237
4238 cleanup_dead();
4239
4240 // The remaining monsters are all alive, but may be outside of the reality bubble.
4241 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4242 // monster::die function is not called.
4243 for( monster &critter : all_monsters() ) {
4244 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4245 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4246 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4247 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4248 despawn_monster( critter );
4249 }
4250 }
4251
4252 // Now, do active NPCs.
4253 for( npc &guy : g->all_npcs() ) {
4254 int turns = 0;
4255 if( guy.is_mounted() ) {
4256 guy.check_mount_is_spooked();
4257 }
4258 m.creature_in_field( guy );
4259 if( !guy.has_effect( effect_npc_suspend ) ) {
4260 guy.process_turn();
4261 }
4262 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4263 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4264 ) {
4265 int moves = guy.moves;
4266 guy.move();
4267 if( moves == guy.moves ) {
4268 // Count every time we exit npc::move() without spending any moves.
4269 turns++;
4270 }
4271
4272 // Turn on debug mode when in infinite loop
4273 // It has to be done before the last turn, otherwise
4274 // there will be no meaningful debug output.
4275 if( turns == 9 ) {
4276 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4277 guy.name );
4278 debug_mode = true;
4279 }
4280 }
4281
4282 // If we spun too long trying to decide what to do (without spending moves),
4283 // Invoke cognitive suspension to prevent an infinite loop.
4284 if( turns == 10 ) {
4285 add_msg( _( "%s faints!" ), guy.name );
4286 guy.reboot();
4287 }
4288
4289 if( !guy.is_dead() ) {
4290 guy.npc_update_body();
4291 }
4292 }
4293 cleanup_dead();
4294}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1987
units::energy get_power_level() const
Definition: character.cpp:1967
void wake_up()
Definition: avatar.cpp:942
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), motion_alarm, calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2113 of file game.cpp.

2115{
2116 const int rate = get_option<int>( "EDGE_SCROLL" );
2117 auto ret = std::make_pair( tripoint_zero, last );
2118 if( rate == -1 ) {
2119 // Fast return when the option is disabled.
2120 return ret;
2121 }
2122 // Ensure the parameters are used even if the #if below is false
2123 ( void ) ctxt;
2124 ( void ) speed;
2125 ( void ) iso;
2126#if (defined TILES || defined _WIN32 || defined WINDOWS)
2127 auto now = std::chrono::steady_clock::now();
2128 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2129 return ret;
2130 } else {
2132 }
2133 const input_event event = ctxt.get_raw_input();
2134 if( event.type == CATA_INPUT_MOUSE ) {
2135 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2136 if( event.mouse_pos.x <= threshold.x ) {
2137 ret.first.x -= speed;
2138 if( iso ) {
2139 ret.first.y -= speed;
2140 }
2141 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2142 ret.first.x += speed;
2143 if( iso ) {
2144 ret.first.y += speed;
2145 }
2146 }
2147 if( event.mouse_pos.y <= threshold.y ) {
2148 ret.first.y -= speed;
2149 if( iso ) {
2150 ret.first.x += speed;
2151 }
2152 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2153 ret.first.y += speed;
2154 if( iso ) {
2155 ret.first.x -= speed;
2156 }
2157 }
2158 ret.second = ret.first;
2159 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2160 ret.first = ret.second;
2161 }
2162#endif
2163 return ret;
2164}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2175 of file game.cpp.

2176{
2177 // overmap has no iso mode
2181 return ret.first;
2182}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2113
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1090
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1091

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2166 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2547 of file game.cpp.

2548{
2549 const std::string save_dir = get_world_base_save_path();
2550 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2551 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2552 const std::string prefix = base64_encode( u.name ) + ".";
2553
2554 if( !assure_dir_exist( graveyard_dir ) ) {
2555 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2556 }
2557
2558 if( !assure_dir_exist( graveyard_save_dir ) ) {
2559 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2560 }
2561
2562 const auto save_files = get_files_from_path( prefix, save_dir );
2563 if( save_files.empty() ) {
2564 debugmsg( "could not find save files in '%s'", save_dir );
2565 }
2566
2567 for( const auto &src_path : save_files ) {
2568 const std::string dst_path = graveyard_save_dir +
2569 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2570
2571 if( rename_file( src_path, dst_path ) ) {
2572 continue;
2573 }
2574
2575 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2576
2577 if( remove_file( src_path ) ) {
2578 continue;
2579 }
2580
2581 debugmsg( "could not remove file '%s'", src_path );
2582 }
2583}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5193 of file game.cpp.

5194{
5195 const optional_vpart_position vp = m.veh_at( u.pos() );
5196 if( !vp ) {
5197 debugmsg( "Tried to exit non-existent vehicle." );
5198 return;
5199 }
5200 vehicle *const veh = &vp->vehicle();
5201 if( u.pos() == dest_loc ) {
5202 debugmsg( "Need somewhere to dismount towards." );
5203 return;
5204 }
5205 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5206 // TODO:: make dir() const correct!
5207 const units::angle d = ray.dir();
5208 add_msg( _( "You dive from the %s." ), veh->name );
5209 m.unboard_vehicle( u.pos() );
5210 u.moves -= 200;
5211 // Dive three tiles in the direction of tox and toy
5212 fling_creature( &u, d, 30, true );
5213 // Hit the ground according to vehicle speed
5214 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5215 if( veh->velocity > 0 ) {
5216 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5217 } else {
5218 fling_creature( &u, veh->face.dir() + 180_degrees,
5219 -( veh->velocity ) / static_cast<float>( 100 ) );
5220 }
5221 }
5222}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:9789

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3628 of file game.cpp.

3629{
3630 // ignore while underground or above limits
3631 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3632 return LIGHT_AMBIENT_MINIMAL;
3633 }
3634
3635 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3636 // Already found the light level for now?
3637 return latest_lightlevels[zlev];
3638 }
3639
3640 float ret = LIGHT_AMBIENT_MINIMAL;
3641
3642 // Sunlight/moonlight related stuff
3644 if( !weather.lightning_active ) {
3646 } else {
3647 // Recent lightning strike has lit the area
3649 }
3650
3652
3653 // Artifact light level changes here. Even though some of these only have an effect
3654 // aboveground it is cheaper performance wise to simply iterate through the entire
3655 // list once instead of twice.
3656 float mod_ret = -1;
3657 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3658 // will trump a lower one.
3659 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3660 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3661 const time_duration left = e->when - calendar::turn;
3662 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3663 if( left > 25_turns ) {
3664 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3665 // and the last 25 scale back towards normal.
3666 } else {
3667 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3668 }
3669 }
3671 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3672 mod_ret = std::max<float>( ret, default_daylight_level() );
3673 }
3674 // If we had a changed light level due to an artifact event then it overwrites
3675 // the natural light level.
3676 if( mod_ret > -1 ) {
3677 ret = mod_ret;
3678 }
3679
3680 // Cap everything to our minimum light level
3681 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3682
3683 latest_lightlevels[zlev] = ret;
3684
3685 return ret;
3686}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1063
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5324 of file game.cpp.

5325{
5326 enum choices : int {
5327 talk = 0,
5328 swap_pos,
5329 push,
5330 examine_wounds,
5331 use_item,
5332 sort_armor,
5333 attack,
5334 disarm,
5335 steal
5336 };
5337
5338 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5339
5340 uilist amenu;
5341
5342 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5343 amenu.addentry( talk, true, 't', _( "Talk" ) );
5344 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5345 !u.is_mounted(), 's', _( "Swap positions" ) );
5346 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5347 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5348 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5349 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5350 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5351 if( !who.is_player_ally() ) {
5352 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5353 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5354 }
5355
5356 amenu.query();
5357
5358 const int choice = amenu.ret;
5359 if( choice == talk ) {
5360 who.talk_to_u();
5361 } else if( choice == swap_pos ) {
5362 if( !prompt_dangerous_tile( who.pos() ) ) {
5363 return true;
5364 }
5365 // TODO: Make NPCs protest when displaced onto dangerous crap
5366 add_msg( _( "You swap places with %s." ), who.name );
5367 swap_critters( u, who );
5368 // TODO: Make that depend on stuff
5369 u.mod_moves( -200 );
5370 } else if( choice == push ) {
5371 // TODO: Make NPCs protest when displaced onto dangerous crap
5372 tripoint oldpos = who.pos();
5373 who.move_away_from( u.pos(), true );
5374 u.mod_moves( -20 );
5375 if( oldpos != who.pos() ) {
5376 add_msg( _( "%s moves out of the way." ), who.name );
5377 } else {
5378 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5379 }
5380 } else if( choice == examine_wounds ) {
5381 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5382
5383 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5384 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5385 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5386 0.0f, 0.0f );
5387 } else if( choice == use_item ) {
5388 static const std::string heal_string( "heal" );
5389 const auto will_accept = []( const item & it ) {
5390 const auto use_fun = it.get_use( heal_string );
5391 if( use_fun == nullptr ) {
5392 return false;
5393 }
5394
5395 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5396
5397 return actor != nullptr &&
5398 actor->limb_power >= 0 &&
5399 actor->head_power >= 0 &&
5400 actor->torso_power >= 0;
5401 };
5402 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5403
5404 if( !loc ) {
5405 add_msg( _( "Never mind" ) );
5406 return false;
5407 }
5408 item &used = *loc;
5409 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5410 if( did_use ) {
5411 // Note: exiting a body part selection menu counts as use here
5412 u.mod_moves( -300 );
5413 }
5414 } else if( choice == sort_armor ) {
5415 who.sort_armor();
5416 u.mod_moves( -100 );
5417 } else if( choice == attack ) {
5418 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5419 u.melee_attack( who, true );
5420 who.on_attacked( u );
5421 }
5422 } else if( choice == disarm ) {
5423 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5424 u.disarm( who );
5425 }
5426 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5427 u.steal( who );
5428 }
5429
5430 return true;
5431}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5847
bool in_sleep_state() const override
Definition: character.cpp:9318
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:250
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2369
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8729
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:4850
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:731
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1449
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2530
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2293
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:552

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 4795 of file game.cpp.

4796{
4797 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
4798}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 9747 of file game.cpp.

9748{
9749 // TODO: Move this to a character method
9750 if( !u.is_mounted() ) {
9751 const item muscle( "muscle" );
9752 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
9753 if( u.has_active_bionic( bid ) ) {// active power gen
9754 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
9755 } else if( u.has_bionic( bid ) ) {// passive power gen
9756 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
9757 }
9758 }
9759
9760 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
9761 if( u.movement_mode_is( CMM_RUN ) ) {
9762 u.mod_power_level( -55_J );
9763 } else {
9764 u.mod_power_level( -35_J );
9765 }
9766 }
9767 }
9768
9769 if( u.movement_mode_is( CMM_RUN ) ) {
9770 if( !u.can_run() ) {
9772 }
9773 }
9774
9775 // apply martial art move bonuses
9776 u.martial_arts_data->ma_onmove_effects( u );
9777
9779}
@ CMM_RUN
Definition: character.h:103
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1329
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1619
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1928
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1877
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 9781 of file game.cpp.

9782{
9783#if defined(TILES)
9784 tilecontext->on_options_changed();
9785#endif
9786 grid_tracker_ptr->on_options_changed();
9787}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1487 of file handle_action.cpp.

1488{
1489 uilist as_m;
1490
1491 as_m.text = _( "What do you want to consume?" );
1492
1493 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1494 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1495 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1496 as_m.query();
1497
1498 switch( as_m.ret ) {
1499 case 0:
1501 break;
1502 case 1:
1504 break;
1505 case 2:
1507 break;
1508 default:
1509 break;
1510 }
1511}
std::vector< uilist_entry > entries
Definition: ui.h:323
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ open_gate()

void game::open_gate ( const tripoint p)

Definition at line 5188 of file game.cpp.

5189{
5190 gates::open_gate( p, u );
5191}
void open_gate(const tripoint &pos, player &p)
opens the gate via player's activity
Definition: gates.cpp:236

References gates::open_gate(), and u.

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4296 of file game.cpp.

4297{
4298 std::vector<npc *> travelling_npcs;
4299 static constexpr int move_search_radius = 600;
4300 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4301 if( !elem ) {
4302 continue;
4303 }
4304 npc *npc_to_add = elem.get();
4305 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4306 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4307 travelling_npcs.push_back( npc_to_add );
4308 }
4309 }
4310 for( auto &elem : travelling_npcs ) {
4311 if( elem->has_omt_destination() ) {
4312 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4313 //recalculate path, we got distracted doing something else probably
4314 elem->omt_path.clear();
4315 }
4316 if( elem->omt_path.empty() ) {
4317 const tripoint_abs_omt &from = elem->global_omt_location();
4318 const tripoint_abs_omt &to = elem->goal;
4319 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4321 if( elem->omt_path.empty() ) {
4322 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4323 elem->get_name(), from.to_string(), to.to_string() );
4324 elem->goal = npc::no_goal_point;
4325 elem->mission = NPC_MISSION_NULL;
4326 }
4327 } else {
4328 if( elem->omt_path.back() == elem->global_omt_location() ) {
4329 elem->omt_path.pop_back();
4330 }
4331 // TODO: fix point types
4332 elem->travel_overmap(
4333 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4334 }
4335 reload_npcs();
4336 }
4337 }
4338 return;
4339}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:970
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2195
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5683 of file game.cpp.

5684{
5685 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5686 if( !p ) {
5687 return;
5688 }
5689
5690 if( p->z != 0 ) {
5691 const tripoint old_pos = u.pos();
5692 vertical_move( p->z, false, true );
5693
5694 if( old_pos != u.pos() ) {
5695 look_around();
5696 vertical_move( p->z * -1, false, true );
5697 }
5698 return;
5699 }
5700
5701 if( m.impassable( u.pos() + *p ) || m.obstructed_by_vehicle_rotation( u.pos(), u.pos() + *p ) ) {
5702 return;
5703 }
5704
5705 peek( u.pos() + *p );
5706}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:977

References _, choose_direction(), map::impassable(), look_around(), m, map::obstructed_by_vehicle_rotation(), peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5708 of file game.cpp.

5709{
5710 u.moves -= 200;
5711 tripoint prev = u.pos();
5712 u.setpos( p );
5713 tripoint center = p;
5714 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5715 true );
5716 u.setpos( prev );
5717
5718 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5719 item_location loc;
5720 avatar_action::plthrow( u, loc, p );
5721 }
5723}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11077 of file game.cpp.

11078{
11079 if( !calendar::once_every( 1_hours ) ) {
11080 return;
11081 }
11082 // Create a new NPC?
11083 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11084 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11085 return;
11086 }
11087
11088 float density = get_option<float>( "NPC_DENSITY" );
11089 static constexpr int density_search_radius = 60;
11090 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11091 if( npc_num > 0.0 ) {
11092 // 100%, 80%, 64%, 52%, 41%, 33%...
11093 density *= std::pow( 0.8f, npc_num );
11094 }
11095
11096 if( !x_in_y( density, 100 ) ) {
11097 return;
11098 }
11099 bool spawn_allowed = false;
11101 int counter = 0;
11102 while( !spawn_allowed ) {
11103 if( counter >= 10 ) {
11104 return;
11105 }
11106 static constexpr int radius_spawn_range = 120;
11107 const tripoint_abs_omt u_omt = u.global_omt_location();
11108 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11109 rng( -radius_spawn_range, radius_spawn_range ) );
11110 spawn_point.z() = 0;
11111 const oter_id oter = overmap_buffer.ter( spawn_point );
11112 // shouldn't spawn on lakes or rivers.
11113 if( !is_river_or_lake( oter ) ) {
11114 spawn_allowed = true;
11115 }
11116 counter += 1;
11117 }
11118 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11119 tmp->normalize();
11120 tmp->randomize();
11121 std::string new_fac_id = "solo_";
11122 new_fac_id += tmp->name;
11123 // create a new "lone wolf" faction for this one NPC
11124 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11125 faction_id( "no_faction" ) );
11126 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11127 // adds the npc to the correct overmap.
11128 // Only spawn random NPCs on z-level 0
11129 // TODO: fix point types
11130 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11131 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11133 tmp->form_opinion( u );
11134 tmp->mission = NPC_MISSION_NULL;
11135 tmp->long_term_goal_action();
11136 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11137 tmp->getID() ) );
11138 // This will make the new NPC active- if its nearby to the player
11139 load_npcs();
11140}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 9479 of file game.cpp.

9480{
9481 if( dest_loc.z != u.posz() && !via_ramp ) {
9482 // No vertical phasing yet
9483 return false;
9484 }
9485
9486 //probability travel through walls but not water
9487 tripoint dest = dest_loc;
9488 // tile is impassable
9489 int tunneldist = 0;
9490 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
9491 while( m.impassable( dest ) ||
9492 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
9493 //add 1 to tunnel distance for each impassable tile in the line
9494 tunneldist += 1;
9495 //Being dimensionally anchored prevents quantum shenanigans.
9496 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
9498 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
9499 return false;
9500 }
9501
9502 if( tunneldist > 24 ) {
9503 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
9504 return false;
9505 }
9506
9507 dest.x += d.x;
9508 dest.y += d.y;
9509 }
9510
9511 if( tunneldist != 0 ) {
9512 if( ( tunneldist - 1 ) * 100_kJ
9513 > //The first 100 was already taken up by the bionic's activation cost.
9514 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
9515 if( tunneldist * 100_kJ >
9517 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
9518 } else {
9519 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
9520 ( 100 * tunneldist ) );
9521 }
9522 return false;
9523 }
9524
9525 if( u.in_vehicle ) {
9526 m.unboard_vehicle( u.pos() );
9527 }
9528
9529 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
9530 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
9531 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
9532 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
9533 u.moves -= ( 50 + ( tunneldist * 50 ) );
9534 u.setpos( dest );
9535
9536 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
9537 m.board_vehicle( u.pos(), &u );
9538 }
9539
9540 u.grab( OBJECT_NONE );
9542 m.creature_on_trap( u );
9543 return true;
9544 }
9545
9546 return false;
9547}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3270
units::energy get_max_power_level() const
Definition: character.cpp:1972
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1201
void on_move_effects()
Definition: game.cpp:9747
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1044
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5654 of file game.cpp.

5655{
5656 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5657 _( "There is nothing to pick up nearby." ),
5658 ACTION_PICKUP, false );
5659 if( !examp_ ) {
5660 return;
5661 }
5662 pickup( *examp_ );
5663}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5665 of file game.cpp.

5666{
5667 // Highlight target
5668 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5669 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5670 } );
5671 add_draw_callback( hilite_cb );
5672
5673 pickup::pick_up( p, 0 );
5674}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5676 of file game.cpp.

5677{
5678 pickup::pick_up( u.pos(), 1 );
5679}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4743 of file game.cpp.

4744{
4745 // TODO: change this into an assert, it must never happen.
4746 if( id.is_null() ) {
4747 return nullptr;
4748 }
4749 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4750}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4743

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4752 of file game.cpp.

4756{
4758 if( forced || can_place_monster( *mon, center ) ) {
4759 where = center;
4760 }
4761
4762 // This loop ensures the monster is placed as close to the center as possible,
4763 // but all places that equally far from the center have the same probability.
4764 for( int r = 1; r <= radius && !where; ++r ) {
4766 }
4767
4768 if( !where ) {
4769 return nullptr;
4770 }
4771 mon->spawn( *where );
4772 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4773}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4725
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4709

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4733 of file game.cpp.

4734{
4735 return place_critter_around( id, p, 0 );
4736}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4738 of file game.cpp.

4739{
4740 return place_critter_around( mon, p, 0 );
4741}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 4775 of file game.cpp.

4776{
4777 // TODO: change this into an assert, it must never happen.
4778 if( id.is_null() ) {
4779 return nullptr;
4780 }
4781 return place_critter_within( make_shared_fast<monster>( id ), range );
4782}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:4775

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 4784 of file game.cpp.

4786{
4787 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
4788 if( !where ) {
4789 return nullptr;
4790 }
4791 mon->spawn( *where );
4792 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4793}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9117 of file game.cpp.

9118{
9119 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9120 if( const cata::optional<std::string> label = vp1.get_label() ) {
9121 add_msg( m_info, _( "Label here: %s" ), *label );
9122 }
9123 std::string signage = m.get_signage( dest_loc );
9124 if( !signage.empty() ) {
9125 if( !u.has_trait( trait_ILLITERATE ) ) {
9126 add_msg( m_info, _( "The sign says: %s" ), signage );
9127 } else {
9128 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9129 }
9130 }
9131 if( m.has_graffiti_at( dest_loc ) ) {
9132 if( !u.has_trait( trait_ILLITERATE ) ) {
9133 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9134 } else {
9135 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9136 }
9137 }
9138 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9139 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9140 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9141 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9142 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9143 dest_loc ) );
9144 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9145 }
9146 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9147 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9148 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9149 dest_loc ) );
9150 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9151 }
9152 }
9153 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9154 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9155 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9156 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9157 if( u.is_mounted() ) {
9158 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9159 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9160 } else {
9161 const bodypart_id bp = u.get_random_body_part();
9162 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9163 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9164 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9165 body_part_name_accusative( bp->token ),
9166 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9167 dest_loc ) );
9168 }
9169 }
9170 }
9171 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9172 u.add_effect( effect_bouldering, 1_turns, num_bp );
9173 } else if( u.has_effect( effect_bouldering ) ) {
9175 }
9176 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9177 u.add_effect( effect_no_sight, 1_turns, num_bp );
9178 } else if( u.has_effect( effect_no_sight ) ) {
9180 }
9181
9182 // If we moved out of the nonant, we need update our map data
9183 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9184 add_msg( _( "The water puts out the flames!" ) );
9186 if( u.is_mounted() ) {
9187 monster *mon = u.mounted_creature.get();
9188 if( mon->has_effect( effect_onfire ) ) {
9190 }
9191 }
9192 }
9193
9194 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9195 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9196 // Immobile monsters can't be displaced.
9197 monster &critter = *mon_ptr;
9198 // TODO: handling for ridden creatures other than players mount.
9199 if( !critter.has_effect( effect_ridden ) ) {
9200 if( u.is_mounted() ) {
9201 std::vector<tripoint> valid;
9202 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9203 if( is_empty( jk ) ) {
9204 valid.push_back( jk );
9205 }
9206 }
9207 if( !valid.empty() ) {
9208 critter.move_to( random_entry( valid ) );
9209 add_msg( _( "You push the %s out of the way." ), critter.name() );
9210 } else {
9211 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9212 return u.pos().xy();
9213 }
9214 } else {
9215 critter.move_to( u.pos(), false,
9216 true ); // Force the movement even though the player is there right now.
9217 add_msg( _( "You displace the %s." ), critter.name() );
9218 }
9219 } else if( !u.has_effect( effect_riding ) ) {
9220 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9221 return u.pos().xy();
9222 }
9223 }
9224
9225 // If the player is in a vehicle, unboard them from the current part
9226 if( u.in_vehicle ) {
9227 m.unboard_vehicle( u.pos() );
9228 }
9229 // Move the player
9230 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9231 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9232 vertical_shift( dest_loc.z );
9233 }
9234
9235 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9236 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9237 vp1 ) ) {
9238 u.stop_hauling();
9239 }
9240 u.setpos( dest_loc );
9241 if( u.is_mounted() ) {
9242 monster *mon = u.mounted_creature.get();
9243 mon->setpos( dest_loc );
9244 mon->process_triggers();
9245 m.creature_in_field( *mon );
9246 }
9247 point submap_shift = update_map( u );
9248 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9249 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9250 // If you must use it you can calculate the position in the new, shifted system with
9251 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9252
9253 //Auto pulp or butcher and Auto foraging
9254 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9256
9257 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9258 if( forage_type != "off" ) {
9259 const auto forage = [&]( const tripoint & pos ) {
9260 const auto &xter_t = m.ter( pos ).obj().examine;
9261 const auto &xfurn_t = m.furn( pos ).obj().examine;
9262 const bool forage_everything = forage_type == "both";
9263 const bool forage_bushes = forage_everything || forage_type == "bushes";
9264 const bool forage_trees = forage_everything || forage_type == "trees";
9265 if( xter_t == &iexamine::none ) {
9266 return;
9267 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9268 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9269 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9270 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9271 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9272 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9273 ) {
9274 xter_t( u, pos );
9275 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9276 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9277 ) {
9278 xfurn_t( u, pos );
9279 }
9280 };
9281
9282 for( auto &elem : adjacentDir ) {
9283 forage( u.pos() + direction_XY( elem ) );
9284 }
9285 }
9286
9287 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9288 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9289 std::vector<item *> corpses;
9290
9291 for( item &it : m.i_at( u.pos() ) ) {
9292 corpses.push_back( &it );
9293 }
9294
9295 if( !corpses.empty() ) {
9296 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9297 for( item *it : corpses ) {
9298 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9299 }
9300 }
9301 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9302 const auto pulp = [&]( const tripoint & pos ) {
9303 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9304 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9305 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9307 u.activity.placement = m.getabs( pos );
9308 u.activity.auto_resume = true;
9309 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9310 return;
9311 }
9312 }
9313 };
9314
9315 if( pulp_butcher == "pulp_adjacent" ) {
9316 for( auto &elem : adjacentDir ) {
9317 pulp( u.pos() + direction_XY( elem ) );
9318 }
9319 } else {
9320 pulp( u.pos() );
9321 }
9322 }
9323 }
9324
9325 //Autopickup
9326 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9327 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9328 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9329 pickup::pick_up( u.pos(), -1 );
9330 }
9331
9332 // If the new tile is a boardable part, board it
9333 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9334 m.board_vehicle( u.pos(), &u );
9335 }
9336
9337 // Traps!
9338 // Try to detect.
9340 if( u.is_mounted() ) {
9342 } else {
9343 m.creature_on_trap( u );
9344 }
9345 // Drench the player if swimmable
9346 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9347 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9348 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9349 }
9350
9351 // List items here
9352 if( !m.has_flag( "SEALED", u.pos() ) ) {
9353 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9354 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9355 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9356 add_msg( _( "There's something here, but you can't see what it is." ) );
9357 } else if( m.has_items( u.pos() ) ) {
9358 std::vector<std::string> names;
9359 std::vector<size_t> counts;
9360 std::vector<item> items;
9361 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9362
9363 std::string next_tname = tmpitem.tname();
9364 std::string next_dname = tmpitem.display_name();
9365 bool by_charges = tmpitem.count_by_charges();
9366 bool got_it = false;
9367 for( size_t i = 0; i < names.size(); ++i ) {
9368 if( by_charges && next_tname == names[i] ) {
9369 counts[i] += tmpitem.charges;
9370 got_it = true;
9371 break;
9372 } else if( next_dname == names[i] ) {
9373 counts[i] += 1;
9374 got_it = true;
9375 break;
9376 }
9377 }
9378 if( !got_it ) {
9379 if( by_charges ) {
9380 names.push_back( tmpitem.tname( tmpitem.charges ) );
9381 counts.push_back( tmpitem.charges );
9382 } else {
9383 names.push_back( tmpitem.display_name( 1 ) );
9384 counts.push_back( 1 );
9385 }
9386 items.push_back( tmpitem );
9387 }
9388 if( names.size() > 10 ) {
9389 break;
9390 }
9391 }
9392 for( size_t i = 0; i < names.size(); ++i ) {
9393 if( !items[i].count_by_charges() ) {
9394 names[i] = items[i].display_name( counts[i] );
9395 } else {
9396 names[i] = items[i].tname( counts[i] );
9397 }
9398 }
9399 int and_the_rest = 0;
9400 for( size_t i = 0; i < names.size(); ++i ) {
9401 //~ number of items: "<number> <item>"
9402 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9403 names[i] = string_format( fmt, counts[i], names[i] );
9404 // Skip the first two.
9405 if( i > 1 ) {
9406 and_the_rest += counts[i];
9407 }
9408 }
9409 if( names.size() == 1 ) {
9410 add_msg( _( "You see here %s." ), names[0] );
9411 } else if( names.size() == 2 ) {
9412 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9413 } else if( names.size() == 3 ) {
9414 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9415 } else if( and_the_rest < 7 ) {
9416 add_msg( vgettext( "You see here %s, %s and %d more item.",
9417 "You see here %s, %s and %d more items.",
9418 and_the_rest ),
9419 names[0], names[1], and_the_rest );
9420 } else {
9421 add_msg( _( "You see here %s and many more items." ), names[0] );
9422 }
9423 }
9424 }
9425 }
9426
9427 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9428 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9429 add_msg( _( "There are vehicle controls here." ) );
9430 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9431 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9432 }
9433 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9434 u.is_mounted() ) {
9435 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9436 }
9437 return submap_shift;
9438}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1755
bool is_hauling() const
Definition: character.cpp:9182
void stop_hauling()
Definition: character.cpp:9173
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1620
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:10600
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6064
std::string furnname(const tripoint &p)
Definition: map.cpp:1464
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2317
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7788
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4750
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7777
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2307
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2293
void setpos(const tripoint &p) override
Definition: monster.cpp:237
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1501
void process_triggers()
Definition: monster.cpp:1192
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:701
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3607
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3572
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2044
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2023
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2032
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2014
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3586
string_id< zone_type > zone_type_id
Definition: type_id.h:192

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9440 of file game.cpp.

9441{
9442 // if player is teleporting around, they don't bring their horse with them
9443 if( u.is_mounted() ) {
9445 u.mounted_creature->remove_effect( effect_ridden );
9446 u.mounted_creature = nullptr;
9447 }
9448 // offload the active npcs.
9449 unload_npcs();
9450 for( monster &critter : all_monsters() ) {
9451 despawn_monster( critter );
9452 }
9453 if( u.in_vehicle ) {
9454 m.unboard_vehicle( u.pos() );
9455 }
9456
9458 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9459 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9460 for( int z = minz; z <= maxz; z++ ) {
9461 m.clear_vehicle_list( z );
9462 }
9464 // offset because load_map expects the coordinates of the top left corner, but the
9465 // player will be centered in the middle of the map.
9466 // TODO: fix point types
9467 const tripoint map_sm_pos(
9468 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9469 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9470 load_map( map_sm_pos );
9471 load_npcs();
9472 m.spawn_monsters( true ); // Static monsters
9474 // update weather now as it could be different on the new location
9476 place_player( player_pos );
9477}
point place_player(const tripoint &dest)
Definition: game.cpp:9117
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:952
void update_overmap_seen()
Definition: game.cpp:10778
level_cache & access_cache(int zlev)
Definition: map.cpp:8659
void clear_vehicle_list(int zlev)
Definition: map.cpp:327
void clear_vehicle_cache()
Definition: map.cpp:309
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:352

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 848 of file game.cpp.

851{
852 std::vector<std::string> search_types = omt_search_types;
853 if( search_types.empty() ) {
854 vehicle veh( id );
855 if( veh.can_float() ) {
856 search_types.push_back( "river" );
857 search_types.push_back( "lake" );
858 } else {
859 search_types.push_back( "field" );
860 search_types.push_back( "road" );
861 }
862 }
863 for( const std::string &search_type : search_types ) {
864 omt_find_params find_params;
865 find_params.must_see = false;
866 find_params.cant_see = false;
867 find_params.types.emplace_back( search_type, ot_match_type::type );
868 // find nearest road
869 find_params.min_distance = min_distance;
870 find_params.search_range = max_distance;
871 // if player spawns underground, park their car on the surface.
872 const tripoint_abs_omt omt_origin( origin, 0 );
873 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
874 // try place vehicle there.
875 tinymap target_map;
876 target_map.load( project_to<coords::sm>( goal ), false );
877 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
878 static constexpr std::array<units::angle, 4> angles = {{
879 0_degrees, 90_degrees, 180_degrees, 270_degrees
880 }
881 };
882 vehicle *veh = target_map.add_vehicle(
883 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
884 if( veh ) {
885 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
886 veh->sm_pos = ms_to_sm_remain( abs_local );
887 veh->pos = abs_local.xy();
889 veh->tracking_on = true;
890 target_map.save();
891 return veh;
892 }
893 }
894 }
895 return nullptr;
896}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6576
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5600
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2087
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1916
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1901
bool tracking_on
Definition: vehicle.h:1991
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6606 of file game.cpp.

6609{
6610 // get global area info according to look_around caret position
6611 // TODO: fix point types
6613 lp ) ) ) );
6614 // we only need the area name and then pass it to print_all_tile_info() function below
6615 const std::string area_name = cur_ter_m->get_name();
6616 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6617}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:5786
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 5786 of file game.cpp.

5791{
5792 visibility_type visibility = VIS_HIDDEN;
5793 const bool inbounds = m.inbounds( lp );
5794 if( inbounds ) {
5795 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5796 }
5797 const Creature *creature = critter_at( lp, true );
5798 switch( visibility ) {
5799 case VIS_CLEAR: {
5800 const optional_vpart_position vp = m.veh_at( lp );
5801 print_terrain_info( lp, w_look, area_name, column, line );
5802 print_fields_info( lp, w_look, column, line );
5803 print_trap_info( lp, w_look, column, line );
5804 print_creature_info( creature, w_look, column, line, last_line );
5805 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
5806 last_line );
5807 print_items_info( lp, w_look, column, line, last_line );
5808 print_graffiti_info( lp, w_look, column, line, last_line );
5809 }
5810 break;
5811 case VIS_BOOMER:
5812 case VIS_BOOMER_DARK:
5813 case VIS_DARK:
5814 case VIS_LIT:
5815 case VIS_HIDDEN:
5816 print_visibility_info( w_look, column, line, visibility );
5817
5818 if( creature != nullptr ) {
5819 std::vector<std::string> buf;
5820 if( u.sees_with_infrared( *creature ) ) {
5821 creature->describe_infrared( buf );
5822 } else if( u.sees_with_specials( *creature ) ) {
5823 creature->describe_specials( buf );
5824 }
5825 for( const std::string &s : buf ) {
5826 mvwprintw( w_look, point( 1, ++line ), s );
5827 }
5828 }
5829 break;
5830 }
5831 if( !inbounds ) {
5832 return;
5833 }
5834 auto this_sound = sounds::sound_at( lp );
5835 if( !this_sound.empty() ) {
5836 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
5837 } else {
5838 // Check other z-levels
5839 tripoint tmp = lp;
5840 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
5841 if( tmp.z == lp.z ) {
5842 continue;
5843 }
5844
5845 auto zlev_sound = sounds::sound_at( tmp );
5846 if( !zlev_sound.empty() ) {
5847 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
5848 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
5849 }
5850 }
5851 }
5852}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6424
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:5956
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:5883
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6048
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5993
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6002
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6011
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:5854
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:5974
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6455
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5993 of file game.cpp.

5995{
5996 int vLines = last_line - line;
5997 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
5998 line = creature->print_info( w_look, ++line, vLines, column );
5999 }
6000}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 5956 of file game.cpp.

5958{
5959 const field &tmpfield = m.field_at( lp );
5960 for( auto &fld : tmpfield ) {
5961 const field_entry &cur = fld.second;
5962 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
5963 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
5964 const int max_width = getmaxx( w_look ) - column - 2;
5965 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
5966 get_fire_fuel_string( lp ) ) - 1;
5967 line += lines;
5968 } else {
5969 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
5970 }
5971 }
5972}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6048 of file game.cpp.

6051{
6052 if( line > last_line ) {
6053 return;
6054 }
6055
6056 const int max_width = getmaxx( w_look ) - column - 2;
6057 if( m.has_graffiti_at( lp ) ) {
6058 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6059 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6060 m.graffiti_at( lp ) );
6061 }
6062}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6011 of file game.cpp.

6014{
6015 if( !m.sees_some_items( lp, u ) ) {
6016 return;
6017 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6018 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6019 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6020 mvwprintz( w_look, point( column, ++line ), c_yellow,
6021 _( "There's something there, but you can't see what it is." ) );
6022 return;
6023 } else {
6024 std::map<std::string, int> item_names;
6025 for( auto &item : m.i_at( lp ) ) {
6026 ++item_names[item.tname()];
6027 }
6028
6029 const int max_width = getmaxx( w_look ) - column - 1;
6030 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6031 // last line but not last item
6032 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6033 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6034 break;
6035 }
6036
6037 if( it->second > 1 ) {
6038 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6039 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6040 it->first.c_str(), it->second );
6041 } else {
6042 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6043 }
6044 }
6045 }
6046}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4726
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 5883 of file game.cpp.

5886{
5887 const int max_width = getmaxx( w_look ) - column - 1;
5888 int lines;
5889
5890 const auto fmt_tile_info = []( const tripoint & lp ) {
5891 map &here = get_map();
5892 std::string ret;
5893 if( debug_mode ) {
5894 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
5895 if( here.has_furn( lp ) ) {
5896 ret += "; " + here.furn( lp )->id.str();
5897 }
5898 } else {
5899 ret = here.tername( lp );
5900 if( here.has_furn( lp ) ) {
5901 ret += "; " + here.furnname( lp );
5902 }
5903 }
5904 return ret;
5905 };
5906
5907 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
5908
5909 if( m.impassable( lp ) ) {
5910 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5911 _( "%s; Impassable" ),
5912 tile );
5913 } else {
5914 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5915 _( "%s; Movement cost %d" ),
5916 tile, m.move_cost( lp ) * 50 );
5917
5918 const auto ll = get_light_level( std::max( 1.0,
5919 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
5920 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
5921 wprintz( w_look, ll.second, ll.first );
5922 }
5923
5924 std::string signage = m.get_signage( lp );
5925 if( !signage.empty() ) {
5926 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5927 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
5928 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
5929 }
5930
5931 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
5932 // Print info about stuff below
5933 tripoint below( lp.xy(), lp.z - 1 );
5934 std::string tile_below = fmt_tile_info( below );
5935
5936 if( !m.has_floor_or_support( lp ) ) {
5937 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5938 _( "Below: %s; No support" ),
5939 tile_below );
5940 } else {
5941 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5942 _( "Below: %s; Walkable" ),
5943 tile_below );
5944 }
5945 }
5946
5947 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5948 m.features( lp ) );
5949 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
5950 m.coverage( lp ) );
5951 if( line < lines ) {
5952 line = lines + map_features - 1;
5953 }
5954}
Manage and cache data about a part of the map.
Definition: map.h:385
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2034
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:617
std::string features(const tripoint &p)
Definition: map.cpp:1709
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6226
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:490
ter_str_id id
Definition: mapdata.h:458

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 5974 of file game.cpp.

5976{
5977 const trap &tr = m.tr_at( lp );
5978 if( tr.can_see( lp, u ) ) {
5979 partial_con *pc = m.partial_con_at( lp );
5980 std::string tr_name;
5981 if( pc && tr.loadid == tr_unfinished_construction ) {
5982 const construction &built = pc->id.obj();
5983 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.description,
5984 pc->counter / 100000 );
5985 } else {
5986 tr_name = tr.name();
5987 }
5988
5989 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
5990 }
5991}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5131
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string description
Definition: construction.h:51
construction_id id
Definition: construction.h:33
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::description, partial_con::id, line(), trap::loadid, m, mvwprintz(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6002 of file game.cpp.

6004{
6005 if( veh ) {
6006 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6007 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6008 }
6009}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 5854 of file game.cpp.

5856{
5857 const char *visibility_message = nullptr;
5858 switch( visibility ) {
5859 case VIS_CLEAR:
5860 visibility_message = _( "Clearly visible." );
5861 break;
5862 case VIS_BOOMER:
5863 visibility_message = _( "A bright pink blur." );
5864 break;
5865 case VIS_BOOMER_DARK:
5866 visibility_message = _( "A pink blur." );
5867 break;
5868 case VIS_DARK:
5869 visibility_message = _( "Darkness." );
5870 break;
5871 case VIS_LIT:
5872 visibility_message = _( "Bright light." );
5873 break;
5874 case VIS_HIDDEN:
5875 visibility_message = _( "Unseen." );
5876 break;
5877 }
5878
5879 mvwprintw( w_look, point( line, column ), visibility_message );
5880 line += 2;
5881}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1743 of file game.cpp.

1744{
1745 if( !u.activity ) {
1746 return;
1747 }
1748
1749 while( u.moves > 0 && u.activity ) {
1750 u.activity.do_turn( u );
1751 }
1752}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11351 of file game.cpp.

11352{
11353 const bool worn = p.is_worn( it );
11354 const bool wielded = ( &it == &p.weapon );
11355 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11356 if( worn ) {
11357 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11358 effects.insert( effects.end(), ew.begin(), ew.end() );
11359 }
11360 if( wielded ) {
11361 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11362 effects.insert( effects.end(), ew.begin(), ew.end() );
11363 }
11364
11365 if( it.is_tool() ) {
11366 // Recharge it if necessary
11367 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11368 //Before incrementing charge, check that any extra requirements are met
11369 if( check_art_charge_req( it ) ) {
11370 switch( it.type->artifact->charge_type ) {
11371 case ARTC_NULL:
11372 case NUM_ARTCS:
11373 break; // dummy entries
11374 case ARTC_TIME:
11375 // Once per hour
11376 if( calendar::once_every( 1_hours ) ) {
11377 it.charges++;
11378 }
11379 break;
11380 case ARTC_SOLAR:
11381 if( calendar::once_every( 10_minutes ) &&
11382 is_in_sunlight( p.pos() ) ) {
11383 it.charges++;
11384 }
11385 break;
11386 // Artifacts can inflict pain even on Deadened folks.
11387 // Some weird Lovecraftian thing. ;P
11388 // (So DON'T route them through mod_pain!)
11389 case ARTC_PAIN:
11390 if( calendar::once_every( 1_minutes ) ) {
11391 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11392 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11393 it.charges++;
11394 }
11395 break;
11396 case ARTC_HP:
11397 if( calendar::once_every( 1_minutes ) ) {
11398 add_msg( m_bad, _( "You feel your body decaying." ) );
11399 p.hurtall( 1, nullptr );
11400 it.charges++;
11401 }
11402 break;
11403 case ARTC_FATIGUE:
11404 if( calendar::once_every( 1_minutes ) ) {
11405 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11406 u.mod_fatigue( 3 * rng( 1, 3 ) );
11407 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11408 it.charges++;
11409 }
11410 break;
11411 // Portals are energetic enough to charge the item.
11412 // Tears in reality are consumed too, but can't charge it.
11413 case ARTC_PORTAL:
11414 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11415 m.remove_field( dest, fd_fatigue );
11416 if( m.tr_at( dest ).loadid == tr_portal ) {
11417 add_msg( m_good, _( "The portal collapses!" ) );
11418 m.remove_trap( dest );
11419 it.charges++;
11420 break;
11421 }
11422 }
11423 break;
11424 }
11425 }
11426 }
11427 }
11428
11429 for( const art_effect_passive &i : effects ) {
11430 switch( i ) {
11431 case AEP_STR_UP:
11432 p.mod_str_bonus( +4 );
11433 break;
11434 case AEP_DEX_UP:
11435 p.mod_dex_bonus( +4 );
11436 break;
11437 case AEP_PER_UP:
11438 p.mod_per_bonus( +4 );
11439 break;
11440 case AEP_INT_UP:
11441 p.mod_int_bonus( +4 );
11442 break;
11443 case AEP_ALL_UP:
11444 p.mod_str_bonus( +2 );
11445 p.mod_dex_bonus( +2 );
11446 p.mod_per_bonus( +2 );
11447 p.mod_int_bonus( +2 );
11448 break;
11449 case AEP_SPEED_UP:
11450 // Handled in player::current_speed()
11451 break;
11452
11453 case AEP_PBLUE:
11454 if( p.get_rad() > 0 ) {
11455 p.mod_rad( -1 );
11456 }
11457 break;
11458
11459 case AEP_SMOKE:
11460 if( one_in( 10 ) ) {
11461 tripoint pt( p.posx() + rng( -1, 1 ),
11462 p.posy() + rng( -1, 1 ),
11463 p.posz() );
11464 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11465 }
11466 break;
11467
11468 case AEP_SNAKES:
11469 break; // Handled in player::hit()
11470
11471 case AEP_EXTINGUISH:
11472 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11473 m.mod_field_age( dest, fd_fire, -1_turns );
11474 }
11475 break;
11476
11477 case AEP_FUN:
11478 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11479 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11480 break;
11481
11482 case AEP_HUNGER:
11483 if( one_in( 100 ) ) {
11484 p.mod_stored_kcal( -10 );
11485 }
11486 break;
11487
11488 case AEP_THIRST:
11489 if( one_in( 120 ) ) {
11490 p.mod_thirst( 1 );
11491 }
11492 break;
11493
11494 case AEP_EVIL:
11495 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11496 p.add_effect( effect_evil, 30_minutes );
11497 if( it.is_armor() ) {
11498 if( !worn ) {
11499 add_msg( _( "You have an urge to wear the %s." ),
11500 it.tname() );
11501 }
11502 } else if( !wielded ) {
11503 add_msg( _( "You have an urge to wield the %s." ),
11504 it.tname() );
11505 }
11506 }
11507 break;
11508
11509 case AEP_SCHIZO:
11510 break; // Handled in player::suffer()
11511
11512 case AEP_RADIOACTIVE:
11513 if( one_in( 4 ) ) {
11514 p.irradiate( 1.0f );
11515 }
11516 break;
11517
11518 case AEP_STR_DOWN:
11519 p.mod_str_bonus( -3 );
11520 break;
11521
11522 case AEP_DEX_DOWN:
11523 p.mod_dex_bonus( -3 );
11524 break;
11525
11526 case AEP_PER_DOWN:
11527 p.mod_per_bonus( -3 );
11528 break;
11529
11530 case AEP_INT_DOWN:
11531 p.mod_int_bonus( -3 );
11532 break;
11533
11534 case AEP_ALL_DOWN:
11535 p.mod_str_bonus( -2 );
11536 p.mod_dex_bonus( -2 );
11537 p.mod_per_bonus( -2 );
11538 p.mod_int_bonus( -2 );
11539 break;
11540
11541 case AEP_SPEED_DOWN:
11542 break; // Handled in player::current_speed()
11543
11544 default:
11545 //Suppress warnings
11546 break;
11547 }
11548 }
11549 // Recalculate, as it might have changed (by mod_*_bonus above)
11550 p.str_cur = p.get_str();
11551 p.int_cur = p.get_int();
11552 p.dex_cur = p.get_dex();
11553 p.per_cur = p.get_per();
11554}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4184
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4179
int str_cur
Definition: character.h:247
void mod_rad(int mod)
Definition: character.cpp:7184
virtual int get_dex() const
Definition: character.cpp:4068
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4299
bool is_worn(const item &thing) const
Definition: character.h:1082
virtual int get_int() const
Definition: character.cpp:4076
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4430
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4174
int int_cur
Definition: character.h:249
int get_rad() const
Definition: character.cpp:7174
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9089
virtual int get_per() const
Definition: character.cpp:4072
void mod_stamina(int mod)
Definition: character.cpp:7211
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8655
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1532
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4189
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1352
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:4926
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7220
bool is_tool() const
Definition: item.cpp:6797
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7247
int charges
Definition: item.h:2195
bool is_armor() const
Definition: item.cpp:6548
const itype * type
Definition: item.h:2156
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5386
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5306
void remove_trap(const tripoint &p)
Definition: map.cpp:5251
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:864

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1704 of file game.cpp.

1705{
1706 if( u.has_effect( effect_sleep ) ) {
1707 // Can't interrupt
1708 return;
1709 }
1710
1711 bool has_activity = u.activity && u.activity.moves_left > 0;
1712 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1713
1714 if( !has_activity && !is_travelling ) {
1715 // Nohing to interrupt
1716 return;
1717 }
1718
1719 // Key poll may be quite expensive, so limit it to 10 times per second.
1720 static auto last_poll = std::chrono::steady_clock::now();
1721 auto now = std::chrono::steady_clock::now();
1722 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1723 ( now - last_poll ).count();
1724
1725 if( difference > 100 ) {
1727 last_poll = now;
1728 }
1729
1730 // If player is performing a task and a monster is dangerously close, warn them
1731 // regardless of previous safemode warnings
1732 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1734 Creature *hostile_critter = is_hostile_very_close();
1735 if( hostile_critter != nullptr ) {
1737 string_format( _( "The %s is dangerously close!" ),
1738 hostile_critter->get_name() ) );
1739 }
1740 }
1741}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9220
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2058
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8729 of file game.cpp.

8730{
8731 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8732
8733 if( !harmful_stuff.empty() &&
8734 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
8735 return false;
8736 }
8737 if( !harmful_stuff.empty() && u.is_mounted() &&
8738 m.tr_at( dest_loc ).loadid == tr_ledge ) {
8739 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
8740 u.mounted_creature->get_name() );
8741 return false;
8742 }
8743 return true;
8744}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11319 of file game.cpp.

11320{
11321 const WORLDPTR active_world = world_generator->active_world;
11322 if( active_world == nullptr ) {
11323 return;
11324 }
11325
11326 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11327 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11328 MAPBUFFER.reset();
11330 try {
11331 setup();
11332 } catch( const std::exception &err ) {
11333 debugmsg( "Error: %s", err.what() );
11334 }
11336 }
11337 } else {
11338 popup_getkey( _( "No saves for %s yet." ), u.name );
11339 }
11340}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2592
void setup()
Definition: game.cpp:561
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11297 of file game.cpp.

11298{
11299 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11300 if( !moves_since_last_save ) {
11301 return;
11302 }
11303 add_msg( m_info, _( "Saving game, this may take a while" ) );
11304
11306 popup.message( "%s", _( "Saving game, this may take a while" ) );
11309
11310 time_t now = time( nullptr ); //timestamp for start of saving procedure
11311
11312 //perform save
11313 save();
11314 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11316 last_save_timestamp = now;
11317}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 549 of file game.cpp.

550{
551 if( was_fullscreen ) {
552 if( !fullscreen ) {
554 }
555 }
556}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 961 of file game.cpp.

962{
963 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
964 // and not invoke "on_load" for those NPCs that avoided unloading this way.
965 unload_npcs();
966 load_npcs();
967}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 522 of file game.cpp.

523{
524#if defined(TILES)
525 try {
526 tilecontext->reinit();
527 tilecontext->load_tileset( get_option<std::string>( "TILES" ), false, true );
528 tilecontext->do_tile_loading_report();
529 } catch( const std::exception &err ) {
530 popup( _( "Loading the tileset failed: %s" ), err.what() );
531 }
532 g->reset_zoom();
533 g->mark_main_ui_adaptor_resize();
534#endif // TILES
535}

References _, g, and popup().

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2333 of file game.cpp.

2334{
2336 return remoteveh_cache;
2337 }
2339 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2340 if( remote_veh_string.str().empty() ||
2342 remoteveh_cache = nullptr;
2343 } else {
2344 tripoint vp;
2345 remote_veh_string >> vp.x >> vp.y >> vp.z;
2346 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2347 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2348 remoteveh_cache = veh;
2349 } else {
2350 remoteveh_cache = nullptr;
2351 }
2352 }
2353 return remoteveh_cache;
2354}
vehicle * remoteveh_cache
Definition: game.h:1066
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3359
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1967 of file game.cpp.

1968{
1969 follower_ids.erase( id );
1970 u.follower_ids.erase( id );
1971}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 4805 of file game.cpp.

4806{
4807 critter_tracker->remove( critter );
4808}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 10817 of file game.cpp.

10818{
10819 for( auto &elem : coming_to_stairs ) {
10820 elem.staircount = 0;
10821 const tripoint pnt( elem.pos().xy(), get_levz() );
10822 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
10823 }
10824
10825 coming_to_stairs.clear();
10826}
std::vector< monster > coming_to_stairs
Definition: game.h:1004

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7195 of file game.cpp.

7196{
7197 const int width = getmaxx( window );
7198 for( int i = 1; i < TERMX; i++ ) {
7199 if( i < width ) {
7200 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7201 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7202 LINE_OXOX ); // -
7203 }
7204
7205 if( i < TERMY - height ) {
7206 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7207 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7208 }
7209 }
7210
7211 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7212 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7213
7214 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7215 LINE_XXXO ); // |-
7216 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7217 LINE_XOXX ); // -|
7218
7219 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7220 wprintz( window, c_white, _( "Items" ) );
7221
7222 std::string sSort;
7223 if( bRadiusSort ) {
7224 //~ Sort type: distance.
7225 sSort = _( "<s>ort: dist" );
7226 } else {
7227 //~ Sort type: category.
7228 sSort = _( "<s>ort: cat" );
7229 }
7230
7231 int letters = utf8_width( sSort );
7232
7233 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7234
7235 std::vector<std::string> tokens;
7236 if( !sFilter.empty() ) {
7237 tokens.emplace_back( _( "<R>eset" ) );
7238 }
7239
7240 tokens.emplace_back( _( "<E>xamine" ) );
7241 tokens.emplace_back( _( "<C>ompare" ) );
7242 tokens.emplace_back( _( "<F>ilter" ) );
7243 tokens.emplace_back( _( "<+/->Priority" ) );
7244
7245 int gaps = tokens.size() + 1;
7246 letters = 0;
7247 int n = tokens.size();
7248 for( int i = 0; i < n; i++ ) {
7249 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7250 }
7251
7252 int usedwidth = letters;
7253 const int gap_spaces = ( width - usedwidth ) / gaps;
7254 usedwidth += gap_spaces * gaps;
7255 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7256
7257 for( int i = 0; i < n; i++ ) {
7258 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7259 tokens[i] ) + gap_spaces;
7260 }
7261}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3694 of file game.cpp.

3695{
3696 for( float &lev : latest_lightlevels ) {
3697 lev = -std::numeric_limits<float>::max();
3698 }
3699}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 2769 of file game.cpp.

2770{
2771 for( auto elem : follower_ids ) {
2772 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
2773 if( !npc_to_get ) {
2774 continue;
2775 }
2776 npc *npc_to_add = npc_to_get.get();
2777 npc_to_add->chatbin.missions.clear();
2778 npc_to_add->chatbin.missions_assigned.clear();
2779 npc_to_add->mission = NPC_MISSION_NULL;
2780 npc_to_add->chatbin.mission_selected = nullptr;
2781 npc_to_add->set_attitude( NPCATT_NULL );
2782 npc_to_add->op_of_u.anger = 0;
2783 npc_to_add->op_of_u.fear = 0;
2784 npc_to_add->op_of_u.trust = 0;
2785 npc_to_add->op_of_u.value = 0;
2786 npc_to_add->op_of_u.owed = 0;
2787 npc_to_add->set_fac( faction_id( "no_faction" ) );
2789 npc_to_add->global_omt_location(),
2790 npc_to_add->getID() ) );
2791
2792 }
2793
2794}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3144
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2640
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:466
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7110 of file game.cpp.

7111{
7112#if defined(TILES)
7114 rescale_tileset( tileset_zoom );
7115#endif // TILES
7116}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 4936 of file game.cpp.

4937{
4938 if( !it.is_corpse() ) {
4939 debugmsg( "Tried to revive a non-corpse." );
4940 return false;
4941 }
4942 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
4943 ( it.get_mtype()->id );
4944 monster &critter = *newmon_ptr;
4945 critter.init_from_item( it );
4946 if( critter.get_hp() < 1 ) {
4947 // Failed reanimation due to corpse being too burned
4948 return false;
4949 }
4950 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
4951 it.has_flag( "QUARTERED" ) ) {
4952 // Failed reanimation due to corpse being butchered
4953 return false;
4954 }
4955
4956 critter.no_extra_death_drops = true;
4957 critter.add_effect( effect_downed, 5_turns, num_bp );
4958 for( const item &component : it.components ) {
4959 critter.corpse_components.push_back( component );
4960 }
4961
4962 if( it.get_var( "zlave" ) == "zlave" ) {
4963 critter.add_effect( effect_pacified, 1_turns, num_bp );
4964 critter.add_effect( effect_pet, 1_turns, num_bp );
4965 }
4966
4967 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
4968 for( auto &ammo : critter.ammo ) {
4969 ammo.second = 0;
4970 }
4971 }
4972
4973 return place_critter_at( newmon_ptr, p );
4974}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4733
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1024
const mtype * get_mtype() const
Definition: item.cpp:6469
std::list< item > components
Definition: item.h:2158
bool has_flag(const std::string &flag) const
Definition: item.cpp:5186
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6464
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2898
bool no_extra_death_drops
Definition: monster.h:482
std::vector< item > corpse_components
Definition: monster.h:459
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2762
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 2870 of file game.cpp.

2871{
2872 try {
2873 if( !save_player_data() ||
2875 !save_artifacts() ||
2876 !save_maps() ||
2877 !get_auto_pickup().save_character() ||
2879 !get_safemode().save_character() ||
2880 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
2881 JsonOut jsout( fout );
2882 uistate.serialize( jsout );
2883 }, _( "uistate data" ) ) ) {
2884 return false;
2885 } else {
2886 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
2887 return true;
2888 }
2889 } catch( std::ios::failure &err ) {
2890 popup( _( "Failed to save game data" ) );
2891 return false;
2892 }
2893}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:2824
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 2805 of file game.cpp.

2806{
2807 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
2808 return ::save_artifacts( artfilename );
2809}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 4976 of file game.cpp.

4977{
4978 int assist_bonus = installer.get_effect_int( effect_assisted );
4979
4980 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
4983 -1 );
4984
4985 int damage = cyborg->damage();
4986 int dmg_lvl = cyborg->damage_level( 4 );
4987 int difficulty = 12;
4988
4989 if( damage != 0 ) {
4990
4991 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
4992 dmg_lvl );
4993
4994 // Damage of the cyborg increases difficulty
4995 difficulty += dmg_lvl;
4996 }
4997
4998 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
4999 int success = chance_of_success - rng( 1, 100 );
5000
5001 if( !g->u.query_yn(
5002 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5003 100 - static_cast<int>( chance_of_success ) ) ) {
5004 return;
5005 }
5006
5007 if( success > 0 ) {
5008 add_msg( m_good, _( "Successfully removed Personality override." ) );
5009 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5010
5011 m.i_rem( couch_pos, cyborg );
5012
5013 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5014 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5015 tmp->normalize();
5016 tmp->load_npc_template( npc_cyborg );
5017 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5019 tmp->hurtall( dmg_lvl * 10, nullptr );
5020 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5021 load_npcs();
5022
5023 } else {
5024 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5025 adjusted_skill ) );
5026 const int fail_type = std::min( 5, failure_level );
5027 switch( fail_type ) {
5028 case 1:
5029 case 2:
5030 add_msg( m_info, _( "The removal fails." ) );
5031 add_msg( m_bad, _( "The body is damaged." ) );
5032 cyborg->set_damage( damage + 1000 );
5033 break;
5034 case 3:
5035 case 4:
5036 add_msg( m_info, _( "The removal fails badly." ) );
5037 add_msg( m_bad, _( "The body is badly damaged!" ) );
5038 cyborg->set_damage( damage + 2000 );
5039 break;
5040 case 5:
5041 add_msg( m_info, _( "The removal is a catastrophe." ) );
5042 add_msg( m_bad, _( "The body is destroyed!" ) );
5043 m.i_rem( couch_pos, cyborg );
5044 break;
5045 default:
5046 break;
5047 }
5048
5049 }
5050
5051}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1886
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1843
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:713
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:700
int damage() const
How much damage has the item sustained?
Definition: item.cpp:695
map_stack::iterator i_rem(const tripoint &p, map_stack::const_iterator it)
Definition: map.cpp:4082
static const skill_id skill_computer("computer")
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 2797 of file game.cpp.

2798{
2799 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
2800 return write_to_file( masterfile, [&]( std::ostream & fout ) {
2801 serialize_master( fout );
2802 }, _( "factions data" ) );
2803}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1238

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 2811 of file game.cpp.

2812{
2813 try {
2814 m.save();
2815 overmap_buffer.save(); // can throw
2816 MAPBUFFER.save(); // can throw
2817 return true;
2818 } catch( const std::exception &err ) {
2819 popup( _( "Failed to save the maps: %s" ), err.what() );
2820 return false;
2821 }
2822}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 2824 of file game.cpp.

2825{
2826 const std::string playerfile = get_player_base_save_path();
2827
2828 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
2829 serialize( fout );
2830 }, _( "player data" ) );
2831 const bool saved_map_memory = u.save_map_memory();
2832 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
2833 std::ostream & fout ) {
2834 fout << memorial().dump();
2835 }, _( "player memorial" ) );
2836#if defined(__ANDROID__)
2837 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
2838 std::ostream & fout ) {
2839 save_shortcuts( fout );
2840 }, _( "quick shortcuts" ) );
2841#endif
2842
2843 return saved_data && saved_map_memory && saved_log
2844#if defined(__ANDROID__)
2845 && saved_shortcuts
2846#endif
2847 ;
2848}
bool save_map_memory()
Definition: avatar.cpp:129
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12034
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:996
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1238 of file savegame.cpp.

1239{
1240 fout << "# version " << savegame_version << std::endl;
1241 try {
1242 JsonOut json( fout, true ); // pretty-print
1243 json.start_object();
1244
1245 json.member( "next_mission_id", next_mission_id );
1246 json.member( "next_npc_id", next_npc_id );
1247
1248 json.member( "active_missions" );
1249 mission::serialize_all( json );
1250
1251 json.member( "factions", *faction_manager_ptr );
1252 json.member( "seed", seed );
1253
1254 json.member( "weather" );
1255 json.start_object();
1256 json.member( "lightning", get_weather().lightning_active );
1257 json.end_object();
1258
1259 json.end_object();
1260 } catch( const JsonError &e ) {
1261 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1262 }
1263}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1229

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1875 of file game.cpp.

1876{
1877 critter_died = true;
1878}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1692 of file game.cpp.

1693{
1694 // remove the previous driving offset,
1695 // store the new offset and apply the new offset.
1702}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1870 of file game.cpp.

1871{
1872 npcs_dirty = true;
1873}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 8657 of file game.cpp.

8658{
8659 safe_mode = mode;
8661}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7118 of file game.cpp.

7119{
7120#if defined(TILES)
7121 if( tileset_zoom != level ) {
7122 tileset_zoom = level;
7123 rescale_tileset( tileset_zoom );
7124 }
7125#else
7126 static_cast<void>( level );
7127#endif // TILES
7128}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2356 of file game.cpp.

2357{
2359 remoteveh_cache = veh;
2360 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2362 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2363 veh = nullptr;
2364 }
2365
2366 if( veh == nullptr ) {
2367 u.remove_value( "remote_controlling_vehicle" );
2368 return;
2369 }
2370
2371 std::stringstream remote_veh_string;
2372 const tripoint vehpos = veh->global_pos3();
2373 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2374 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2375}
void remove_value(const std::string &key)
Definition: creature.cpp:1336

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 561 of file game.cpp.

562{
563 loading_ui ui( true );
564 {
567 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
570
572 }
573
575
576 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
577 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
578 }
579
580 m = map( get_option<bool>( "ZLEVELS" ) );
581
583 next_mission_id = 1;
584 new_game = true;
585 uquit = QUIT_NO; // We haven't quit the game
586 bVMonsterLookFire = true;
587
588 // invalidate calendar caches in case we were previously playing
589 // a different world
590 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
591 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
592
595
596 turnssincelastmon = 0; //Auto safe mode init
597
600 coming_to_stairs.clear();
601 active_npc.clear();
602 faction_manager_ptr->clear();
607
608 SCT.vSCT.clear(); //Delete pending messages
609
610 stats().clear();
611 // reset kill counts
612 kill_tracker_ptr->clear();
614 // reset follower list
615 follower_ids.clear();
616 scent.reset();
617
619 remoteveh_cache = nullptr;
620
621 token_provider_ptr->clear();
622 // back to menu for save loading, new game etc
623}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:4810
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2704
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4663 of file game.cpp.

4664{
4665 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4666 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4667 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4668 }
4669 if( critter.is_monster() ) {
4670 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4671 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4672 return std::dynamic_pointer_cast<T>( mon_ptr );
4673 }
4674 }
4675 }
4676 if( critter.is_npc() ) {
4677 for( auto &cur_npc : active_npc ) {
4678 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4679 return std::dynamic_pointer_cast<T>( cur_npc );
4680 }
4681 }
4682 }
4683 return nullptr;
4684}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12047 of file game.cpp.

12048{
12049 for( tripoint &p : destination_preview ) {
12050 p += delta;
12051 }
12052}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11052 of file game.cpp.

11053{
11054 // If either shift argument is non-zero, we're shifting.
11055 if( shift == tripoint_zero ) {
11056 return;
11057 }
11058 for( monster &critter : all_monsters() ) {
11059 if( shift.xy() != point_zero ) {
11060 critter.shift( shift.xy() );
11061 }
11062
11063 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11064 // We're inbounds, so don't despawn after all.
11065 // No need to shift Z-coordinates, they are absolute
11066 continue;
11067 }
11068 // Either a vertical shift or the critter is now outside of the reality bubble,
11069 // anyway: it must be saved and removed.
11070 despawn_monster( critter );
11071 }
11072 // The order in which zombies are shifted may cause zombies to briefly exist on
11073 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11074 critter_tracker->rebuild_cache();
11075}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12054 of file game.cpp.

12055{
12056 ///\EFFECT_DEX decreases chances of slipping while climbing
12057 int climb = u.dex_cur;
12058 if( u.has_trait( trait_BADKNEES ) ) {
12059 climb = climb / 2;
12060 }
12061 if( one_in( climb ) ) {
12062 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12063 if( climb <= 1 ) {
12064 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12065 }
12066 return true;
12067 }
12068 return false;
12069}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 4821 of file game.cpp.

4822{
4823 if( one_in( 100 ) ) {
4824 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4825 tmp->normalize();
4826 tmp->randomize( NC_HALLU );
4827 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
4828 if( !critter_at( p, true ) ) {
4830 load_npcs();
4831 return true;
4832 } else {
4833 return false;
4834 }
4835 }
4836
4838 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
4839 phantasm->hallucination = true;
4840 phantasm->spawn( p );
4841
4842 //Don't attempt to place phantasms inside of other creatures
4843 if( !critter_at( phantasm->pos(), true ) ) {
4844 return critter_tracker->add( phantasm );
4845 } else {
4846 return false;
4847 }
4848}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 2865 of file game.cpp.

2866{
2867 return *spell_events_ptr;
2868}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 11616 of file game.cpp.

11617{
11618 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
11619 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
11620 scen->has_flag( "SUM_ADV_START" );
11621
11623 if( scen_season ) {
11624 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
11626 get_option<int>( "INITIAL_TIME" );
11627 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
11628 if( scen->has_flag( "SPR_START" ) ) {
11630 } else if( scen->has_flag( "SUM_START" ) ) {
11633 } else if( scen->has_flag( "AUT_START" ) ) {
11636 } else if( scen->has_flag( "WIN_START" ) ) {
11639 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
11642 } else {
11643 debugmsg( "The Unicorn" );
11644 }
11645 } else {
11646 // No scenario, so use the starting date+time configured in world options
11647 int initial_days = get_option<int>( "INITIAL_DAY" );
11648 if( initial_days == -1 ) {
11649 // 0 - 363 for a 91 day season
11650 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
11651 }
11653
11654 // Determine the season based off how long the seasons are set to be
11655 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
11656 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
11657 if( season_number == 0 ) {
11659 } else if( season_number == 1 ) {
11661 } else if( season_number == 2 ) {
11663 } else {
11665 }
11666
11668 + 1_hours * get_option<int>( "INITIAL_TIME" )
11669 + 1_days * get_option<int>( "SPAWN_DELAY" );
11670 }
11671
11673}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1003
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 648 of file game.cpp.

649{
650 if( !gamemode ) {
651 gamemode = std::make_unique<special_game>();
652 }
653
654 seed = rng_bits();
655 new_game = true;
658 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
659 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
661
663
666 popup.message( "%s", _( "Please wait as we build your world" ) );
669
670 load_master();
671 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
672
676 do {
677 omtstart = start_loc.find_player_initial_location();
678 if( omtstart == overmap::invalid_tripoint ) {
679 if( query_yn(
680 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
683 } else {
684 return false;
685 }
686 }
687 } while( omtstart == overmap::invalid_tripoint );
688
689 start_loc.prepare_map( omtstart );
690
691 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
692 if( u.starting_vehicle &&
693 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
694 std::vector<std::string> {} ) ) {
695 debugmsg( "could not place starting vehicle" );
696 }
697
698 if( scen->has_map_extra() ) {
699 // Map extras can add monster spawn points and similar and should be done before the main
700 // map is loaded.
701 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
702 }
703
704 // TODO: fix point types
705 tripoint lev = project_to<coords::sm>( omtstart ).raw();
706 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
707 lev.x -= HALF_MAPSIZE;
708 lev.y -= HALF_MAPSIZE;
709 load_map( lev );
710
713 // Do this after the map cache has been built!
714 start_loc.place_player( u );
715 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
718 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
720 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
721
722 u.moves = 0;
723 u.process_turn(); // process_turn adds the initial move points
727 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
729
730 //Reset character safe mode/pickup rules
735
736 //Put some NPCs in there!
737 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
738 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
739 !g->scen->has_flag( "LONE_START" ) ) ) {
741 }
742 //Load NPCs. Set nearby npcs to active.
743 load_npcs();
744 // Spawn the monsters
745 const bool spawn_near =
746 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
747 // Surrounded start ones
748 if( spawn_near ) {
749 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
750 }
751
752 m.spawn_monsters( !spawn_near ); // Static monsters
753
754 // Make sure that no monsters are near the player
755 // This can happen in lab starts
756 if( !spawn_near ) {
757 for( monster &critter : all_monsters() ) {
758 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
759 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
760 remove_zombie( critter );
761 }
762 }
763 }
764
765 //Create mutation_category_level
767 //Calculate mutation drench protection stats
770 if( scen->has_flag( "FIRE_START" ) ) {
771 start_loc.burn( omtstart, 3, 3 );
772 }
773 if( scen->has_flag( "INFECTED" ) ) {
775 }
776 if( scen->has_flag( "BAD_DAY" ) ) {
777 u.add_effect( effect_flu, 1000_minutes );
778 u.add_effect( effect_drunk, 270_minutes );
779 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
780 }
781 if( scen->has_flag( "HELI_CRASH" ) ) {
782 start_loc.handle_heli_crash( u );
783 bool success = false;
784 for( auto v : m.get_vehicles() ) {
785 std::string name = v.v->type.str();
786 std::string search = std::string( "helicopter" );
787 if( name.find( search ) != std::string::npos ) {
788 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
789 const tripoint pos = vp.pos();
790 u.setpos( pos );
791
792 // Delete the items that would have spawned here from a "corpse"
793 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
794 vehicle_stack here = v.v->get_items( sp );
795
796 for( auto iter = here.begin(); iter != here.end(); ) {
797 iter = here.erase( iter );
798 }
799 }
800
801 auto mons = critter_tracker->find( pos );
802 if( mons != nullptr ) {
803 critter_tracker->remove( *mons );
804 }
805
806 success = true;
807 break;
808 }
809 if( success ) {
810 v.v->name = "Bird Wreckage";
811 break;
812 }
813 }
814 }
815 }
816 if( scen->has_flag( "BORDERED" ) ) {
817 overmap &starting_om = get_cur_om();
818 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
819 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
821 }
822
823 }
824 for( auto &e : u.inv_dump() ) {
825 e->set_owner( g->u );
826 }
827 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
828 update_map( u );
829 // Profession pets
830 for( const mtype_id &elem : u.starting_pets ) {
831 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
832 mon->friendly = -1;
833 mon->add_effect( effect_pet, 1_turns, num_bp );
834 } else {
835 add_msg( m_debug, "cannot place starting pet, no space!" );
836 }
837 }
838 // Assign all of this scenario's missions to the player.
839 for( const mission_type_id &m : scen->missions() ) {
840 const auto mission = mission::reserve_new( m, character_id() );
841 mission->assign( u );
842 }
843
844 g->events().send<event_type::game_start>( u.getID() );
845 return true;
846}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2216
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7944
void set_stamina(int new_stamina)
Definition: character.cpp:7206
time_point next_climate_control_check
Definition: character.h:2215
int get_stamina_max() const
Definition: character.cpp:7197
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7921
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:11616
void create_starting_npcs()
Definition: game.cpp:974
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:11914
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:848
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6376
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2163
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:604
vproto_id starting_vehicle
Definition: player.h:616
std::vector< mtype_id > starting_pets
Definition: player.h:617
start_location_id start_location
Definition: player.h:605
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:127
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:98
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10415 of file game.cpp.

10416{
10417 // Find target items and quantities thereof for the new activity
10418 std::vector<item_location> target_items;
10419 std::vector<int> quantities;
10420
10421 map_stack items = m.i_at( pos );
10422 for( item &it : items ) {
10423 // Liquid cannot be picked up
10424 if( it.made_of( LIQUID ) ) {
10425 continue;
10426 }
10427 target_items.emplace_back( map_cursor( pos ), &it );
10428 // Quantity of 0 means move all
10429 quantities.push_back( 0 );
10430 }
10431
10432 if( target_items.empty() ) {
10433 // Nothing to haul
10434 return;
10435 }
10436
10437 // Whether the destination is inside a vehicle (not supported)
10438 const bool to_vehicle = false;
10439 // Destination relative to the player
10440 const tripoint relative_destination{};
10441
10443 target_items,
10444 quantities,
10445 to_vehicle,
10446 relative_destination
10447 ) ) );
10448}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 2855 of file game.cpp.

2856{
2857 return *stats_tracker_ptr;
2858}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 4850 of file game.cpp.

4851{
4852 if( &a == &b ) {
4853 // No need to do anything, but print a debugmsg anyway
4854 debugmsg( "Tried to swap %s with itself", a.disp_name() );
4855 return true;
4856 }
4857 if( critter_at( a.pos() ) != &a ) {
4858 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4859 b.disp_name(), critter_at( a.pos() )->disp_name() );
4860 return false;
4861 }
4862 if( critter_at( b.pos() ) != &b ) {
4863 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4864 a.disp_name(), critter_at( b.pos() )->disp_name() );
4865 return false;
4866 }
4867 // Simplify by "sorting" the arguments
4868 // Only the first argument can be u
4869 // If swapping player/npc with a monster, monster is second
4870 bool a_first = a.is_player() ||
4871 ( a.is_npc() && !b.is_player() );
4872 Creature &first = a_first ? a : b;
4873 Creature &second = a_first ? b : a;
4874 // Possible options:
4875 // both first and second are monsters
4876 // second is a monster, first is a player or an npc
4877 // first is a player, second is an npc
4878 // both first and second are npcs
4879 if( first.is_monster() ) {
4880 monster *m1 = dynamic_cast< monster * >( &first );
4881 monster *m2 = dynamic_cast< monster * >( &second );
4882 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
4883 debugmsg( "Couldn't swap two monsters" );
4884 return false;
4885 }
4886
4887 critter_tracker->swap_positions( *m1, *m2 );
4888 return true;
4889 }
4890
4891 player *u_or_npc = dynamic_cast< player * >( &first );
4892 player *other_npc = dynamic_cast< player * >( &second );
4893
4894 if( u_or_npc->in_vehicle ) {
4895 m.unboard_vehicle( u_or_npc->pos() );
4896 }
4897
4898 if( other_npc && other_npc->in_vehicle ) {
4899 m.unboard_vehicle( other_npc->pos() );
4900 }
4901
4902 tripoint temp = second.pos();
4903 second.setpos( first.pos() );
4904
4905 if( first.is_player() ) {
4906 walk_move( temp );
4907 } else {
4908 first.setpos( temp );
4909 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4910 m.board_vehicle( u_or_npc->pos(), u_or_npc );
4911 }
4912 }
4913
4914 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4915 m.board_vehicle( other_npc->pos(), other_npc );
4916 }
4917 return true;
4918}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:8795
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7187 of file game.cpp.

7188{
7189 popup( _( "This binary was not compiled with tiles support." ) );
7190 return false;
7191}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7181 of file game.cpp.

7182{
7183 popup( _( "This binary was not compiled with tiles support." ) );
7184 return false;
7185}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 539 of file game.cpp.

540{
541 if( fullscreen ) {
542 was_fullscreen = true;
544 } else {
545 was_fullscreen = false;
546 }
547}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11223 of file game.cpp.

11224{
11226}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 501 of file game.cpp.

502{
503#if !defined(TILES)
506#else
507 toggle_fullscreen_window();
508#endif
509}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 511 of file game.cpp.

512{
513#if defined(TILES)
515 clear_window_area( w_pixel_minimap );
516 }
519#endif // TILES
520}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2377 of file game.cpp.

2378{
2379 bool new_destination = true;
2380 if( !destination_preview.empty() ) {
2381 auto &final_destination = destination_preview.back();
2382 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2383 // Second click
2384 new_destination = false;
2386 destination_preview.clear();
2388 if( act == ACTION_NULL ) {
2389 // Something went wrong
2391 return false;
2392 }
2393 }
2394 }
2395
2396 if( new_destination ) {
2398 u.get_path_avoid() );
2399 return false;
2400 }
2401
2402 return true;
2403}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2405 of file game.cpp.

2406{
2407 const bool cleared_destination = !destination_preview.empty();
2409 destination_preview.clear();
2410
2411 if( cleared_destination ) {
2412 // Produce no-op if auto-move had just been cleared on this action
2413 // e.g. from a previous single left mouse click. This has the effect
2414 // of right-click canceling an auto-move before it is initiated.
2415 return false;
2416 }
2417
2418 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2419 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2420 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2421 if( !u.sees( *mon ) ) {
2422 add_msg( _( "Nothing relevant here." ) );
2423 return false;
2424 }
2425
2426 if( !u.weapon.is_gun() ) {
2427 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2428 return false;
2429 }
2430
2431 // TODO: Add weapon range check. This requires weapon to be reloaded.
2432
2433 act = ACTION_FIRE;
2434 } else if( is_adjacent &&
2435 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2436 true ) ) {
2437 act = ACTION_CLOSE;
2438 } else if( is_self ) {
2440 } else if( is_adjacent ) {
2442 } else {
2443 add_msg( _( "Nothing relevant here." ) );
2444 return false;
2445 }
2446
2447 return true;
2448}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3953
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 952 of file game.cpp.

953{
954 for( const auto &npc : active_npc ) {
955 npc->on_unload();
956 }
957
958 active_npc.clear();
959}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2645

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map( tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ) );
207
208 safe_mode = static_cast<safe_mode_type>( tmprun );
209 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
211 }
212
213 std::string linebuff;
214 std::string linebuf;
215 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
216 scent.deserialize( linebuf );
217 scent.deserialize( linebuff, true );
218 } else {
219 scent.reset();
220 }
221 data.read( "active_monsters", *critter_tracker );
222
223 coming_to_stairs.clear();
224 for( auto elem : data.get_array( "stair_monsters" ) ) {
225 monster stairtmp;
226 elem.read( stairtmp );
227 coming_to_stairs.push_back( stairtmp );
228 }
229
230 if( data.has_object( "kill_tracker" ) ) {
231 data.read( "kill_tracker", *kill_tracker_ptr );
232 } else {
233 // Legacy support for when kills were stored directly in game
234 std::map<mtype_id, int> kills;
235 std::vector<std::string> npc_kills;
236 for( const JsonMember member : data.get_object( "kills" ) ) {
237 kills[mtype_id( member.name() )] = member.get_int();
238 }
239
240 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
241 npc_kills.push_back( npc_name );
242 }
243
244 kill_tracker_ptr->reset( kills, npc_kills );
245 }
246
247 data.read( "player", u );
248 data.read( "stats_tracker", *stats_tracker_ptr );
249 data.read( "achievements_tracker", *achievements_tracker_ptr );
250 data.read( "token_provider", token_provider_ptr );
251 Messages::deserialize( data );
252
253 } catch( const JsonError &jsonerr ) {
254 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
255 return;
256 }
257}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:259
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:402
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1188 of file savegame.cpp.

1189{
1191 chkversion( fin );
1192 if( savegame_loading_version < 11 ) {
1193 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1194 popup->message(
1195 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1199 }
1200 try {
1201 // single-pass parsing example
1202 JsonIn jsin( fin );
1203 jsin.start_object();
1204 while( !jsin.end_object() ) {
1205 std::string name = jsin.get_member_name();
1206 if( name == "next_mission_id" ) {
1207 next_mission_id = jsin.get_int();
1208 } else if( name == "next_npc_id" ) {
1209 next_npc_id.deserialize( jsin );
1210 } else if( name == "active_missions" ) {
1212 } else if( name == "factions" ) {
1213 jsin.read( *faction_manager_ptr );
1214 } else if( name == "seed" ) {
1215 jsin.read( seed );
1216 } else if( name == "weather" ) {
1217 JsonObject w = jsin.get_object();
1218 w.read( "lightning", get_weather().lightning_active );
1219 } else {
1220 // silently ignore anything else
1221 jsin.skip_value();
1222 }
1223 }
1224 } catch( const JsonError &e ) {
1225 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1226 }
1227}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1178

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 10683 of file game.cpp.

10684{
10685 point shift;
10686
10687 while( x < HALF_MAPSIZE_X ) {
10688 x += SEEX;
10689 shift.x--;
10690 }
10691 while( x >= HALF_MAPSIZE_X + SEEX ) {
10692 x -= SEEX;
10693 shift.x++;
10694 }
10695 while( y < HALF_MAPSIZE_Y ) {
10696 y += SEEY;
10697 shift.y--;
10698 }
10699 while( y >= HALF_MAPSIZE_Y + SEEY ) {
10700 y -= SEEY;
10701 shift.y++;
10702 }
10703
10704 if( shift == point_zero ) {
10705 // adjust player position
10706 u.setpos( tripoint( x, y, get_levz() ) );
10707 // Update what parts of the world map we can see
10708 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
10709 // TODO: only make this call if we changed z-level
10711 // Not actually shifting the submaps, all the stuff below would do nothing
10712 return point_zero;
10713 }
10714
10715 // this handles loading/unloading submaps that have scrolled on or off the viewport
10716 // NOLINTNEXTLINE(cata-use-named-point-constants)
10717 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
10718 point remaining_shift = shift;
10719 while( remaining_shift != point_zero ) {
10720 point this_shift = clamp( remaining_shift, size_1 );
10721 m.shift( this_shift );
10722 remaining_shift -= this_shift;
10723 }
10724
10725 grid_tracker_ptr->load( m );
10726
10727 // Shift monsters
10728 shift_monsters( tripoint( shift, 0 ) );
10729 const point shift_ms = sm_to_ms_copy( shift );
10730 u.shift_destination( -shift_ms );
10731
10732 // Shift NPCs
10733 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
10734 ( *it )->shift( shift );
10735 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
10736 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
10737 //Remove the npc from the active list. It remains in the overmap list.
10738 ( *it )->on_unload();
10739 it = active_npc.erase( it );
10740 } else {
10741 it++;
10742 }
10743 }
10744
10745 scent.shift( shift_ms );
10746
10747 // Also ensure the player is on current z-level
10748 // get_levz() should later be removed, when there is no longer such a thing
10749 // as "current z-level"
10750 u.setpos( tripoint( x, y, get_levz() ) );
10751
10752 // Only do the loading after all coordinates have been shifted.
10753
10754 // Check for overmap saved npcs that should now come into view.
10755 // Put those in the active list.
10756 load_npcs();
10757
10758 // Make sure map cache is consistent since it may have shifted.
10759 if( m.has_zlevels() ) {
10760 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
10761 m.invalidate_map_cache( zlev );
10762 }
10763 } else {
10765 }
10767
10768 // Spawn monsters if appropriate
10769 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
10770 m.spawn_monsters( false ); // Static monsters
10771
10772 // Update what parts of the world map we can see
10774
10775 return shift;
10776}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11052
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6745
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 10677 of file game.cpp.

10678{
10679 point p2( p.posx(), p.posy() );
10680 return update_map( p2.x, p2.y );
10681}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 10778 of file game.cpp.

10779{
10780 const tripoint_abs_omt ompos = u.global_omt_location();
10781 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
10782 const int dist_squared = dist * dist;
10783 // We can always see where we're standing
10784 overmap_buffer.set_seen( ompos, true );
10785 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
10786 const point_rel_omt delta = p.xy() - ompos.xy();
10787 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
10788 if( trigdist && h_squared > dist_squared ) {
10789 continue;
10790 }
10791 if( delta == point_rel_omt() ) {
10792 // 1. This case is already handled outside of the loop
10793 // 2. Calculating multiplier would cause division by zero
10794 continue;
10795 }
10796 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
10797 point abs_delta = delta.raw().abs();
10798 int max_delta = std::max( abs_delta.x, abs_delta.y );
10799 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
10800 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
10801 float sight_points = dist;
10802 for( auto it = line.begin();
10803 it != line.end() && sight_points >= 0; ++it ) {
10804 const oter_id &ter = overmap_buffer.ter( *it );
10805 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
10806 }
10807 if( sight_points >= 0 ) {
10808 tripoint_abs_omt seen( p );
10809 do {
10810 overmap_buffer.set_seen( seen, true );
10811 --seen.z();
10812 } while( seen.z() >= 0 );
10813 }
10814 }
10815}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:771
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 10830 of file game.cpp.

10831{
10832 // Search for the stairs closest to the player.
10833 std::vector<int> stairx;
10834 std::vector<int> stairy;
10835 std::vector<int> stairdist;
10836
10837 const bool from_below = monstairz < get_levz();
10838
10839 if( coming_to_stairs.empty() ) {
10840 return;
10841 }
10842
10843 if( m.has_zlevels() ) {
10844 debugmsg( "%d monsters coming to stairs on a map with z-levels",
10845 coming_to_stairs.size() );
10846 coming_to_stairs.clear();
10847 }
10848
10849 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
10850 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
10851 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
10852 stairx.push_back( dest.x );
10853 stairy.push_back( dest.y );
10854 stairdist.push_back( rl_dist( dest, u.pos() ) );
10855 }
10856 }
10857 if( stairdist.empty() ) {
10858 return; // Found no stairs?
10859 }
10860
10861 // Find closest stairs.
10862 size_t si = 0;
10863 for( size_t i = 0; i < stairdist.size(); i++ ) {
10864 if( stairdist[i] < stairdist[si] ) {
10865 si = i;
10866 }
10867 }
10868
10869 // Find up to 4 stairs for distance stairdist[si] +1
10870 std::vector<int> nearest;
10871 nearest.push_back( si );
10872 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
10873 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
10874 nearest.push_back( i );
10875 }
10876 }
10877 // Randomize the stair choice
10878 si = random_entry_ref( nearest );
10879
10880 // Attempt to spawn zombies.
10881 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
10882 point mpos( stairx[si], stairy[si] );
10883 monster &critter = coming_to_stairs[i];
10884 const tripoint dest {
10885 mpos, g->get_levz()
10886 };
10887
10888 // We might be not be visible.
10889 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
10890 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
10891 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
10892 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
10893 continue;
10894 }
10895
10896 critter.staircount -= 4;
10897 // Let the player know zombies are trying to come.
10898 if( u.sees( dest ) ) {
10899 std::string dump;
10900 if( critter.staircount > 4 ) {
10901 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
10902 } else {
10903 if( critter.staircount > 0 ) {
10904 dump += ( from_below ?
10905 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
10906 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
10907 critter.name(),
10908 m.tername( dest ) ) :
10909 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
10910 critter.name(),
10911 m.tername( dest ) ) );
10912 }
10913 }
10914
10915 add_msg( m_warning, dump );
10916 } else {
10918 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
10919 }
10920
10921 if( critter.staircount > 0 ) {
10922 continue;
10923 }
10924
10925 if( is_empty( dest ) ) {
10926 critter.spawn( dest );
10927 critter.staircount = 0;
10928 place_critter_at( make_shared_fast<monster>( critter ), dest );
10929 if( u.sees( dest ) ) {
10930 if( !from_below ) {
10931 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
10932 critter.name(),
10933 m.tername( dest ) );
10934 } else {
10935 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
10936 critter.name(),
10937 m.tername( dest ) );
10938 }
10939 }
10940 coming_to_stairs.erase( coming_to_stairs.begin() + i );
10941 continue;
10942 } else if( u.pos() == dest ) {
10943 // Monster attempts to push player of stairs
10945 int tries = 0;
10946
10947 // the critter is now right on top of you and will attack unless
10948 // it can find a square to push you into with one of his tries.
10949 const int creature_push_attempts = 9;
10950 const int player_throw_resist_chance = 3;
10951
10952 critter.spawn( dest );
10953 while( tries < creature_push_attempts ) {
10954 tries++;
10955 push.x = rng( -1, 1 );
10956 push.y = rng( -1, 1 );
10957 point ipos( mpos + push );
10958 tripoint pos( ipos, get_levz() );
10959 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
10960 critter.can_move_to( pos ) ) {
10961 bool resiststhrow = ( u.is_throw_immune() ) ||
10963 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
10964 u.moves -= 25; // small charge for avoiding the push altogether
10965 add_msg( _( "The %s fails to push you back!" ),
10966 critter.name() );
10967 return; //judo or leg brace prevent you from getting pushed at all
10968 }
10969 // Not accounting for tentacles latching on, so..
10970 // Something is about to happen, lets charge half a move
10971 u.moves -= 50;
10972 if( resiststhrow && ( u.is_throw_immune() ) ) {
10973 //we have a judoka who isn't getting pushed but counterattacking now.
10974 mattack::thrown_by_judo( &critter );
10975 return;
10976 }
10977 std::string msg;
10978 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
10979 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
10980 // dodge 12 - never get downed
10981 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
10982 u.add_effect( effect_downed, 2_turns );
10983 msg = _( "The %s pushed you back hard!" );
10984 } else {
10985 msg = _( "The %s pushed you back!" );
10986 }
10987 add_msg( m_warning, msg.c_str(), critter.name() );
10988 u.setx( u.posx() + push.x );
10989 u.sety( u.posy() + push.y );
10990 return;
10991 }
10992 }
10994 _( "The %s tried to push you back but failed! It attacks you!" ),
10995 critter.name() );
10996 critter.melee_attack( u );
10997 u.moves -= 50;
10998 return;
10999 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11000 // Monster attempts to displace a monster from the stairs
11001 monster &other = *mon_ptr;
11002 critter.spawn( dest );
11003
11004 // the critter is now right on top of another and will push it
11005 // if it can find a square to push it into inside of his tries.
11006 const int creature_push_attempts = 9;
11007 const int creature_throw_resist = 4;
11008
11009 int tries = 0;
11010 point push2;
11011 while( tries < creature_push_attempts ) {
11012 tries++;
11013 push2.x = rng( -1, 1 );
11014 push2.y = rng( -1, 1 );
11015 point ipos2( mpos + push2 );
11016 tripoint pos( ipos2, get_levz() );
11017 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11018 continue;
11019 }
11020 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11021 other.setpos( tripoint( ipos2, get_levz() ) );
11022 other.moves -= 50;
11023 std::string msg;
11024 if( one_in( creature_throw_resist ) ) {
11025 other.add_effect( effect_downed, 2_turns );
11026 msg = _( "The %1$s pushed the %2$s hard." );
11027 } else {
11028 msg = _( "The %1$s pushed the %2$s." );
11029 }
11030 add_msg( m_neutral, msg, critter.name(), other.name() );
11031 return;
11032 }
11033 }
11034 return;
11035 }
11036 }
11037}
void setx(int x)
Definition: character.h:788
void sety(int y)
Definition: character.h:791
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:811
int monstairz
Definition: game.h:1005
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8580
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:256
int posy() const override
Definition: monster.h:500
void melee_attack(Creature &target)
Definition: monster.cpp:1370
int staircount
Definition: monster.h:511
void spawn(const tripoint &p)
Definition: monster.cpp:481
int posx() const override
Definition: monster.h:497
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4671
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 4800 of file game.cpp.

4801{
4802 return critter_tracker->update_pos( critter, pos );
4803}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4583 of file game.cpp.

4584{
4585 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4586 add_msg( m_info, _( "You can not read a computer screen!" ) );
4587 return;
4588 }
4589 if( u.is_blind() ) {
4590 // we don't have screen readers in game
4591 add_msg( m_info, _( "You can not see a computer screen!" ) );
4592 return;
4593 }
4594 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4595 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4596 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4597 return;
4598 }
4599
4600 computer *used = m.computer_at( p );
4601
4602 if( used == nullptr ) {
4603 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4604 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4605 } else {
4606 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4607 }
4608 return;
4609 }
4610
4611 computer_session( *used ).use();
4612}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5532
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2039 of file game.cpp.

2040{
2041 basecamp camp = m.hoist_submap_camp( u.pos() );
2042 if( camp.is_valid() ) {
2043 overmap_buffer.add_camp( camp );
2045 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2046 std::string camp_name = _( "Faction Camp" );
2047 camp.set_name( camp_name );
2048 overmap_buffer.add_camp( camp );
2050 }
2051}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5563
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5558
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1981 of file game.cpp.

1982{
1983 for( auto &veh : m.get_vehicles() ) {
1984 vehicle *v = veh.v;
1987 if( other_v ) {
1988 // the other vehicle is towing us.
1989 v->tow_data.set_towing( other_v, v );
1991 }
1992 }
1993 }
1994}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:6117
towing_data tow_data
Definition: vehicle.h:1944

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 1996 of file game.cpp.

1997{
1998 for( monster &m : all_monsters() ) {
1999 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
2000 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
2001 if( !mounted_pl ) {
2002 // Target no longer valid.
2003 m.mounted_player_id = character_id();
2004 m.remove_effect( effect_ridden );
2005 continue;
2006 }
2007 mounted_pl->mounted_creature = shared_from( m );
2008 mounted_pl->setpos( m.pos() );
2009 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2010 m.mounted_player = mounted_pl;
2011 }
2012 }
2013}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2015 of file game.cpp.

2016{
2017 // Make sure visible followers are in the list.
2018 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2019 return guy.is_player_ally();
2020 } );
2021 for( npc *guy : visible_followers ) {
2022 update_faction_api( guy );
2023 add_npc_follower( guy->getID() );
2024 }
2025 // Make sure overmapbuffered NPC followers are in the list.
2026 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2027 npc *guy = temp_guy.get();
2028 if( guy->is_player_ally() ) {
2029 update_faction_api( guy );
2030 add_npc_follower( guy->getID() );
2031 }
2032 }
2033 // Make sure that serialized player followers sync up with game list
2034 for( const auto &temp_id : u.follower_ids ) {
2035 add_npc_follower( temp_id );
2036 }
2037}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1961
static void update_faction_api(npc *guy)
Definition: game.cpp:1973

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10004 of file game.cpp.

10005{
10006 if( u.is_mounted() ) {
10007 auto mons = u.mounted_creature.get();
10008 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10009 if( !mons->check_mech_powered() ) {
10010 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10011 mons->get_name() );
10012 return;
10013 }
10014 }
10015 }
10016
10017 // > and < are used for diving underwater.
10018 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10019 if( movez == -1 ) {
10020 if( u.is_underwater() ) {
10021 add_msg( m_info, _( "You are already underwater!" ) );
10022 return;
10023 }
10024 if( u.worn_with_flag( "FLOTATION" ) ) {
10025 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10026 return;
10027 }
10028 u.set_underwater( true );
10029 ///\EFFECT_STR increases breath-holding capacity while diving
10030 u.oxygen = 30 + 2 * u.str_cur;
10031 add_msg( _( "You dive underwater!" ) );
10032 } else {
10033 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10034 u.set_underwater( false );
10035 add_msg( _( "You surface." ) );
10036 } else {
10037 add_msg( m_info, _( "You try to surface but can't!" ) );
10038 }
10039 }
10040 u.moves -= 100;
10041 return;
10042 }
10043
10044 // Force means we're going down, even if there's no staircase, etc.
10045 bool climbing = false;
10046 int move_cost = 100;
10047 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10048 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10049 // Climbing
10050 if( m.has_floor_or_support( stairs ) ) {
10051 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10052 return;
10053 }
10054
10055 std::vector<tripoint> pts;
10056 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10057 if( m.passable( pt ) &&
10058 m.has_floor_or_support( pt ) ) {
10059 pts.push_back( pt );
10060 }
10061 }
10062
10063 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10064
10065 if( cost == 0 ) {
10066 if( u.has_trait( trait_WEB_ROPE ) ) {
10067 if( pts.empty() ) {
10068 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10069 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10070 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10071 add_msg( m_info, _( "You can't spin a web rope there." ) );
10072 } else if( g->m.has_furn( u.pos() ) ) {
10073 add_msg( m_info, _( "There is already furniture at that location." ) );
10074 } else {
10075 if( query_yn( "Spin a rope and climb?" ) ) {
10076 add_msg( m_good, _( "You spin a rope of web." ) );
10077 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10078 u.mod_moves( to_turns<int>( 2_seconds ) );
10080 vertical_move( movez, force, peeking );
10081 }
10082 }
10083 }
10084
10085 } else {
10086 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10087
10088 }
10089 return;
10090
10091 }
10092
10093 if( cost <= 0 || pts.empty() ) {
10094 add_msg( m_info,
10095 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10096 return;
10097 } else {
10098 // TODO: Make it an extended action
10099 climbing = true;
10100 move_cost = cost;
10101
10103 if( !pnt ) {
10104 return;
10105 }
10106 stairs = *pnt;
10107 }
10108 }
10109
10110 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10111 add_msg( m_info, _( "You can't go down here!" ) );
10112 return;
10113 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10114 add_msg( m_info, _( "You can't go up here!" ) );
10115 return;
10116 }
10117
10118 if( force ) {
10119 // Let go of a grabbed cart.
10120 u.grab( OBJECT_NONE );
10121 } else if( u.grab_point != tripoint_zero ) {
10122 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10123 return;
10124 }
10125
10126 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10127 // is called or when the map is loaded on new z-level (== false).
10128 // This caches the z-level we start the movement on (current) and the level we're want to end.
10129 const int z_before = get_levz();
10130 const int z_after = get_levz() + movez;
10131 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10132 debugmsg( "Tried to move outside allowed range of z-levels" );
10133 return;
10134 }
10135
10136 if( !u.move_effects( false ) ) {
10137 return;
10138 }
10139
10140 // Check if there are monsters are using the stairs.
10141 bool slippedpast = false;
10142 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10143 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10144 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10145 coming_to_stairs[0].name() );
10146 // Roll.
10147 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10148
10149 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10150 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10151 ///\EFFECT_STR increases chance of moving past monsters on stairs
10152
10153 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10154 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10155 if( coming_to_stairs.size() > 4 ) {
10156 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10157 dexroll /= 4;
10158 strroll /= 2;
10159 } else if( coming_to_stairs.size() > 1 ) {
10160 add_msg( m_warning, _( "There's something else behind it!" ) );
10161 dexroll /= 2;
10162 }
10163
10164 if( dexroll < 14 || strroll < 12 ) {
10166 u.moves -= 100;
10167 return;
10168 }
10169
10170 add_msg( _( "You manage to slip past!" ) );
10171 slippedpast = true;
10172 u.moves -= 100;
10173 }
10174
10175 // Shift the map up or down
10176
10177 std::unique_ptr<map> tmp_map_ptr;
10178 if( !m.has_zlevels() ) {
10179 tmp_map_ptr = std::make_unique<map>();
10180 }
10181
10182 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10183 if( m.has_zlevels() ) {
10184 // We no longer need to shift the map here! What joy
10185 } else {
10186 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10187 }
10188
10189 // Find the corresponding staircase
10190 bool rope_ladder = false;
10191 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10192 if( !force && !climbing ) {
10193 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10194 if( !pnt ) {
10195 return;
10196 }
10197 stairs = *pnt;
10198 }
10199
10200 if( !force ) {
10201 monstairz = z_before;
10202 }
10203 // Save all monsters that can reach the stairs, remove them from the tracker,
10204 // then despawn the remaining monsters. Because it's a vertical shift, all
10205 // monsters are out of the bounds of the map and will despawn.
10206 shared_ptr_fast<monster> stored_mount;
10207 if( u.is_mounted() && !m.has_zlevels() ) {
10208 // Store a *copy* of the mount, so we can remove the original monster instance
10209 // from the tracker before the map shifts.
10210 // Map shifting would otherwise just despawn the mount and would later respawn it.
10211 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10213 }
10214 if( !m.has_zlevels() ) {
10215 const tripoint to = u.pos();
10216 for( monster &critter : all_monsters() ) {
10217 // if its a ladder instead of stairs - most zombies can't climb that.
10218 // unless that have a special flag to allow them to do so.
10219 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10220 critter.has_effect( effect_ridden ) ||
10221 critter.has_effect( effect_tied ) ) {
10222 continue;
10223 }
10224 int turns = critter.turns_to_reach( to.xy() );
10225 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10226 && !slippedpast ) {
10227 critter.staircount = 10 + turns;
10228 critter.on_unload();
10229 coming_to_stairs.push_back( critter );
10230 remove_zombie( critter );
10231 }
10232 }
10233 auto mons = critter_tracker->find( g->u.pos() );
10234 if( mons != nullptr ) {
10235 critter_tracker->remove( *mons );
10236 }
10237 shift_monsters( tripoint( 0, 0, movez ) );
10238 }
10239
10240 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10241 std::vector<monster *> monsters_following;
10242 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10243 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10244 [this]( const shared_ptr_fast<npc> &np ) {
10245 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10246 rl_dist( np->pos(), u.pos() ) < 2;
10247 } );
10248 }
10249
10250 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10251 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10252 for( monster &critter : all_monsters() ) {
10253 if( ladder && !critter.climbs() ) {
10254 continue;
10255 }
10256 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10257 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10258 !critter.has_effect( effect_tied ) ) ) {
10259 monsters_following.push_back( &critter );
10260 }
10261 }
10262 }
10263
10264 if( u.is_mounted() ) {
10265 monster *crit = u.mounted_creature.get();
10266 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10267 crit->use_mech_power( -1 );
10268 if( u.movement_mode_is( CMM_WALK ) ) {
10269 crit->use_mech_power( -2 );
10270 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10271 crit->use_mech_power( -1 );
10272 } else if( u.movement_mode_is( CMM_RUN ) ) {
10273 crit->use_mech_power( -3 );
10274 }
10275 }
10276 } else {
10277 u.moves -= move_cost;
10278 }
10279 for( const auto &np : npcs_to_bring ) {
10280 if( np->in_vehicle ) {
10281 m.unboard_vehicle( np->pos() );
10282 }
10283 }
10284 const tripoint old_pos = g->u.pos();
10285 point submap_shift;
10286 vertical_shift( z_after );
10287 if( !force ) {
10288 submap_shift = update_map( stairs.x, stairs.y );
10289 }
10290
10291 // if an NPC or monster is on the stiars when player ascends/descends
10292 // they may end up merged on th esame tile, do some displacement to resolve that.
10293 // if, in the weird case of it not being possible to displace;
10294 // ( how did the player even manage to approach the stairs, if so? )
10295 // then nothing terrible happens, its just weird.
10296 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10297 std::string crit_name;
10298 bool player_displace = false;
10300 if( displace.has_value() ) {
10301 npc *guy = g->critter_at<npc>( u.pos(), true );
10302 if( guy ) {
10303 crit_name = guy->get_name();
10304 tripoint old_pos = guy->pos();
10305 if( !guy->is_enemy() ) {
10306 guy->move_away_from( u.pos(), true );
10307 if( old_pos != guy->pos() ) {
10308 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10309 }
10310 } else {
10311 player_displace = true;
10312 }
10313 }
10314 monster *mon = g->critter_at<monster>( u.pos(), true );
10315 // if the monster is ridden by the player or an NPC:
10316 // Dont displace them. If they are mounted by a friendly NPC,
10317 // then the NPC will already have been displaced just above.
10318 // if they are ridden by the player, we want them to coexist on same tile
10319 if( mon && !mon->mounted_player ) {
10320 crit_name = mon->get_name();
10321 if( mon->friendly == -1 ) {
10322 mon->setpos( *displace );
10323 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10324 } else {
10325 player_displace = true;
10326 }
10327 }
10328 if( player_displace ) {
10329 u.setpos( *displace );
10330 u.moves -= 20;
10331 add_msg( _( "You push past %s blocking the way." ), crit_name );
10332 }
10333 } else {
10334 debugmsg( "Failed to find a spot to displace into." );
10335 }
10336 }
10337
10338 // Now that we know the player's destination position, we can move their mount as well
10339 if( u.is_mounted() ) {
10340 if( stored_mount ) {
10341 assert( !m.has_zlevels() );
10342 stored_mount->spawn( g->u.pos() );
10343 if( critter_tracker->add( stored_mount ) ) {
10344 u.mounted_creature = stored_mount;
10345 }
10346 } else {
10347 u.mounted_creature->setpos( g->u.pos() );
10348 }
10349 }
10350
10351 if( !npcs_to_bring.empty() ) {
10352 // Would look nicer randomly scrambled
10353 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10354 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10355 [this]( const tripoint & c ) {
10356 return !is_empty( c );
10357 } ), candidates.end() );
10358
10359 for( const auto &np : npcs_to_bring ) {
10360 const auto found = std::find_if( candidates.begin(), candidates.end(),
10361 [this, np]( const tripoint & c ) {
10362 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10363 } );
10364 if( found != candidates.end() ) {
10365 // TODO: De-uglify
10366 np->setpos( *found );
10367 np->place_on_map();
10368 np->setpos( *found );
10369 candidates.erase( found );
10370 }
10371
10372 if( candidates.empty() ) {
10373 break;
10374 }
10375 }
10376
10377 reload_npcs();
10378 }
10379
10380 // This ugly check is here because of stair teleport bullshit
10381 // TODO: Remove stair teleport bullshit
10382 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10383 for( monster *m : monsters_following ) {
10384 m->set_dest( g->u.pos() );
10385 }
10386 }
10387
10388 if( rope_ladder ) {
10389 m.ter_set( u.pos(), t_rope_up );
10390 }
10391
10392 if( m.ter( stairs ) == t_manhole_cover ) {
10393 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10394 m.ter_set( stairs, t_manhole );
10395 }
10396
10397 // Wouldn't work and may do strange things
10398 if( u.is_hauling() && !m.has_zlevels() ) {
10399 add_msg( _( "You cannot haul items here." ) );
10400 u.stop_hauling();
10401 }
10402
10403 if( u.is_hauling() ) {
10404 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10405 start_hauling( adjusted_pos );
10406 }
10407
10408 m.invalidate_map_cache( g->get_levz() );
10409 // Upon force movement, traps can not be avoided.
10410 m.creature_on_trap( u, !force );
10411
10413}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:102
@ CMM_CROUCH
Definition: character.h:104
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1535
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:882
int oxygen
Definition: character.h:1530
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8945
std::string get_name() const override
Definition: character.cpp:6094
void start_hauling(const tripoint &pos)
Definition: game.cpp:10415
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10450
bool use_mech_power(int amt)
Definition: monster.cpp:2372
Character * mounted_player
Definition: monster.h:460
void set_underwater(bool)
Definition: player.cpp:516
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:9954
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12073
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9352
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4177

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 10637 of file game.cpp.

10638{
10639 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
10640 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
10641 return;
10642 }
10643
10644 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
10645 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
10646 z_before, z_after );
10647 return;
10648 }
10649 // Figure out where we know there are up/down connectors
10650 // Fill in all the tiles we know about (e.g. subway stations)
10651 static const int REVEAL_RADIUS = 40;
10652 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
10653 const tripoint_abs_omt cursp_before( p.xy(), z_before );
10654 const tripoint_abs_omt cursp_after( p.xy(), z_after );
10655
10656 if( !overmap_buffer.seen( cursp_before ) ) {
10657 continue;
10658 }
10659 if( overmap_buffer.has_note( cursp_after ) ) {
10660 // Already has a note -> never add an AUTO-note
10661 continue;
10662 }
10663 const oter_id &ter = overmap_buffer.ter( cursp_before );
10664 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
10665 if( z_after > z_before && ter->has_flag( known_up ) &&
10666 !ter2->has_flag( known_down ) ) {
10667 overmap_buffer.set_seen( cursp_after, true );
10668 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
10669 } else if( z_after < z_before && ter->has_flag( known_down ) &&
10670 !ter2->has_flag( known_up ) ) {
10671 overmap_buffer.set_seen( cursp_after, true );
10672 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
10673 }
10674 }
10675}
bool inbounds_z(const int z) const
Definition: map.h:1665
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 10600 of file game.cpp.

10601{
10602 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10603 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
10604 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
10605 return;
10606 }
10607
10608 // TODO: Implement dragging stuff up/down
10609 u.grab( OBJECT_NONE );
10610
10611 scent.reset();
10612
10613 u.setz( z_after );
10614 const int z_before = get_levz();
10615 if( !m.has_zlevels() ) {
10617 m.access_cache( z_before ).vehicle_list.clear();
10618 m.access_cache( z_before ).zone_vehicles.clear();
10619 m.access_cache( z_before ).map_memory_seen_cache.reset();
10620 m.set_transparency_cache_dirty( z_before );
10621 m.set_outside_cache_dirty( z_before );
10622 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
10623 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
10624 reload_npcs();
10625 } else {
10626 // Shift the map itself
10627 m.vertical_shift( z_after );
10628 }
10629
10630 m.spawn_monsters( true );
10631 // this may be required after a vertical shift if z-levels are not enabled
10632 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
10634 vertical_notes( z_before, z_after );
10635}
void setz(int z)
Definition: character.h:794
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:10637
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:406
void set_outside_cache_dirty(const int zlev)
Definition: map.h:443
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6864
std::set< vehicle * > zone_vehicles
Definition: map.h:359
std::set< vehicle * > vehicle_list
Definition: map.h:358

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 8795 of file game.cpp.

8796{
8797 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
8798 if( u.get_size() > MS_MEDIUM ) {
8799 add_msg( m_warning, _( "You can't fit there." ) );
8800 return false; // character too large to fit through a tight passage
8801 }
8802 if( u.is_mounted() ) {
8803 monster *mount = u.mounted_creature.get();
8804 if( mount->get_size() > MS_MEDIUM ) {
8805 add_msg( m_warning, _( "Your mount can't fit there." ) );
8806 return false; // char's mount is too large for tight passages
8807 }
8808 }
8809 }
8810
8811 if( u.is_mounted() ) {
8812 auto mons = u.mounted_creature.get();
8813 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
8814 if( !mons->check_mech_powered() ) {
8815 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
8816 mons->get_name() );
8817 return false;
8818 }
8819 }
8820 if( !mons->move_effects( false ) ) {
8821 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
8822 return false;
8823 }
8824 }
8825 const optional_vpart_position vp_here = m.veh_at( u.pos() );
8826 const optional_vpart_position vp_there = m.veh_at( dest_loc );
8827
8828 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
8829 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
8830 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
8831
8832 const tripoint furn_pos = u.pos() + u.grab_point;
8833 const tripoint furn_dest = dest_loc + u.grab_point;
8834
8835 bool grabbed = u.get_grab_type() != OBJECT_NONE;
8836 if( grabbed ) {
8837 const tripoint dp = dest_loc - u.pos();
8838 pushing = dp == u.grab_point;
8839 pulling = dp == -u.grab_point;
8840 }
8841 if( grabbed && dest_loc.z != u.posz() ) {
8842 add_msg( m_warning, _( "You let go of the grabbed object." ) );
8843 grabbed = false;
8844 u.grab( OBJECT_NONE );
8845 }
8846
8847 // Now make sure we're actually holding something
8848 const vehicle *grabbed_vehicle = nullptr;
8849 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
8850 // We only care about shifting, because it's the only one that can change our destination
8851 if( m.has_furn( u.pos() + u.grab_point ) ) {
8852 shifting_furniture = !pushing && !pulling;
8853 } else {
8854 // We were grabbing a furniture that isn't there
8855 grabbed = false;
8856 }
8857 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
8858 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
8859 if( grabbed_vehicle == nullptr ) {
8860 // We were grabbing a vehicle that isn't there anymore
8861 grabbed = false;
8862 }
8863 } else if( grabbed ) {
8864 // We were grabbing something WEIRD, let's pretend we weren't
8865 grabbed = false;
8866 }
8867 if( u.grab_point != tripoint_zero && !grabbed ) {
8868 add_msg( m_warning, _( "Can't find grabbed object." ) );
8869 u.grab( OBJECT_NONE );
8870 }
8871
8872 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
8873 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
8874 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8875 tripoint diff = dest_loc - u.pos();
8876 if( diff.x < 0 ) {
8877 diff.x -= 2;
8878 } else if( diff.x > 0 ) {
8879 diff.x += 2;
8880 }
8881 if( diff.y < 0 ) {
8882 diff.y -= 2;
8883 } else if( diff.y > 0 ) {
8884 diff.y += 2;
8885 }
8886 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
8887 dest_loc );
8888 }
8889 return false;
8890 }
8891 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8892 return false;
8893 }
8894 if( u.is_mounted() && !pushing && vp_there ) {
8895 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
8896 return false;
8897 }
8898 u.set_underwater( false );
8899
8900 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
8901 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8902 if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "ALWAYS" &&
8903 !prompt_dangerous_tile( dest_loc ) ) {
8904 return true;
8905 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "RUNNING" &&
8906 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8908 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
8909 enumerate_as_string( harmful_stuff ) );
8910 return true;
8911 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "CROUCHING" &&
8912 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8914 _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ),
8915 enumerate_as_string( harmful_stuff ) );
8916 return true;
8917 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "NEVER" &&
8918 !u.movement_mode_is( CMM_RUN ) ) {
8920 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
8921 enumerate_as_string( harmful_stuff ) );
8922 return true;
8923 }
8924 }
8925 // Used to decide whether to print a 'moving is slow message
8926 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
8927
8928 int modifier = 0;
8929 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
8930 modifier = -m.furn( dest_loc ).obj().movecost;
8931 }
8932
8933 int multiplier = 1;
8934 if( u.is_on_ground() ) {
8935 multiplier *= 3;
8936 }
8937
8938 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
8939 via_ramp ) * multiplier;
8940 if( grabbed_move( dest_loc - u.pos() ) ) {
8941 return true;
8942 } else if( mcost == 0 ) {
8943 return false;
8944 }
8945 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
8946 const int previous_moves = u.moves;
8947 if( u.is_mounted() ) {
8948 auto crit = u.mounted_creature.get();
8949 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
8950 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
8951 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
8952 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
8953 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
8954 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
8955 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
8956 return false;
8957 }
8958 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
8959 const double encumb_moves = u.get_weight() / 4800.0_gram;
8960 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
8961 if( u.movement_mode_is( CMM_WALK ) ) {
8962 crit->use_mech_power( -2 );
8963 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
8964 crit->use_mech_power( -1 );
8965 } else if( u.movement_mode_is( CMM_RUN ) ) {
8966 crit->use_mech_power( -3 );
8967 }
8968 } else {
8969 u.moves -= u.run_cost( mcost, diag );
8970 /**
8971 TODO:
8972 This should really use the mounted creatures stamina, if mounted.
8973 Monsters don't currently have stamina however.
8974 For the time being just don't burn players stamina when mounted.
8975 */
8976 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
8977 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
8978 u.burn_move_stamina( previous_moves - u.moves );
8979 } else {
8980 //Burn half as much stamina if vehicle has wheels, without changing move time
8981 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
8982 }
8983 }
8984 // Max out recoil & reset aim point
8987
8988 // Print a message if movement is slow
8989 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
8990 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
8991 m.has_flag_ter_or_furn( "FUNGUS",
8992 dest_loc ); //fungal furniture has no slowing effect on mycus characters
8993 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
8994 mcost_to > 4 || mcost_from > 4 ) &&
8995 !( u.has_trait( trait_M_IMMUNE ) && fungus );
8996 if( slowed && !u.is_mounted() ) {
8997 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
8998 if( mcost_to >= mcost_from ) {
8999 if( auto displayed_part = vp_there.part_displayed() ) {
9000 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9001 displayed_part->part().name() );
9002 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9003 } else {
9004 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9005 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9006 }
9007 } else {
9008 if( auto displayed_part = vp_here.part_displayed() ) {
9009 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9010 displayed_part->part().name() );
9011 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9012 } else {
9013 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9014 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9015 }
9016 }
9017 }
9018 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9019 ( !u.footwear_factor() ||
9020 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9021 // DX and IN are long suits for Cephalopods,
9022 // so this shouldn't cause too much hardship
9023 // Presumed that if it's swimmable, they're
9024 // swimming and won't stick
9025 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9026
9027 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9028 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9029 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9030 u.mod_fatigue( 1 );
9031 }
9032 }
9033 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9034 int volume = u.is_stealthy() ? 3 : 6;
9035 volume *= u.mutation_value( "noise_modifier" );
9036 if( volume > 0 ) {
9038 volume = 2;
9039 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9040 volume = 12;
9041 }
9042 if( u.movement_mode_is( CMM_RUN ) ) {
9043 volume *= 1.5;
9044 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9045 volume /= 2;
9046 }
9047 if( u.is_mounted() ) {
9048 auto mons = u.mounted_creature.get();
9049 switch( mons->get_size() ) {
9050 case MS_TINY:
9051 volume = 0; // No sound for the tinies
9052 break;
9053 case MS_SMALL:
9054 volume /= 3;
9055 break;
9056 case MS_MEDIUM:
9057 break;
9058 case MS_LARGE:
9059 volume *= 1.5;
9060 break;
9061 case MS_HUGE:
9062 volume *= 2;
9063 break;
9064 default:
9065 break;
9066 }
9067 if( mons->has_flag( MF_LOUDMOVES ) ) {
9068 volume += 6;
9069 }
9070 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9071 "none", "none" );
9072 } else {
9073 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9074 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9075 }
9077 }
9078
9079 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9080 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9081 "misc", "rattling" );
9082 }
9083 }
9084
9085 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9086 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9087 }
9088
9089 if( dest_loc != u.pos() ) {
9091 }
9092
9093 tripoint oldpos = u.pos();
9094 point submap_shift = place_player( dest_loc );
9095 point ms_shift = sm_to_ms_copy( submap_shift );
9096 oldpos = oldpos - ms_shift;
9097
9098 if( pulling ) {
9099 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9100 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9101 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9102 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9103 m.remove_field( shifted_furn_pos, fd_fire );
9104 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9105 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9106 }
9107
9108 if( u.is_hauling() ) {
9109 start_hauling( oldpos );
9110 }
9111
9113
9114 return true;
9115}
void burn_move_stamina(int moves)
Definition: character.cpp:7221
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3220
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3664
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:962
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6749
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:541
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3240
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:9721
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8724
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1833
m_size get_size() const override
Definition: monster.cpp:2672
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:608
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2148
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2507 of file game.cpp.

2508{
2509 win_screen();
2511 memorial().add(
2512 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2513 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2514 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2515 if( !u.is_dead_state() ) {
2518 }
2519}
void win_screen()
Definition: game.cpp:2521
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2521 of file game.cpp.

2522{
2523 // TODO: Move this wall somewhere
2525 std::string msg = _( "You managed to close the portal and end the invasion!" );
2526 msg += '\n';
2527 if( u.is_dead_state() ) {
2529 "Unfortunately, you had to sacrifice your life to achieve this." );
2530 msg += colorize( t, c_red ) + '\n';
2531 memorial().add(
2532 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2533 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2534 } else {
2535 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2536 msg += colorize( t, c_green ) + '\n';
2537 memorial().add(
2538 pgettext( "memorial_male", "Safely closed the portal." ),
2539 pgettext( "memorial_female", "Safely closed the portal." ) );
2540 }
2541 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2542 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2543 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2544 popup( msg );
2545}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 2910 of file game.cpp.

2911{
2912 const std::string &memorial_dir = PATH_INFO::memorialdir();
2913 const std::string &memorial_active_world_dir = memorial_dir +
2914 world_generator->active_world->world_name + "/";
2915
2916 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
2917 if( !assure_dir_exist( memorial_dir ) ) {
2918 debugmsg( "Could not make '%s' directory", memorial_dir );
2919 return;
2920 }
2921
2922 if( !assure_dir_exist( memorial_active_world_dir ) ) {
2923 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
2924 return;
2925 }
2926
2927 std::string path = memorial_active_world_dir + filename + ".txt";
2928
2929 write_to_file( path, [&]( std::ostream & fout ) {
2930 memorial().write( fout, sLastWords );
2931 }, _( "player memorial" ) );
2932}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6144 of file game.cpp.

6145{
6146 const tripoint stored_view_offset = u.view_offset;
6147
6149
6150 const int zone_ui_height = 12;
6151 const int zone_options_height = 7;
6152
6153 const int width = 45;
6154
6155 int offsetX = 0;
6156 int max_rows = 0;
6157
6158 catacurses::window w_zones;
6159 catacurses::window w_zones_border;
6160 catacurses::window w_zones_info;
6161 catacurses::window w_zones_info_border;
6162 catacurses::window w_zones_options;
6163
6164 bool show = true;
6165
6166 ui_adaptor ui;
6167 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6168 if( !show ) {
6169 ui.position( point_zero, point_zero );
6170 return;
6171 }
6172 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6173 TERMX - width : 0;
6174 const int w_zone_height = TERMY - zone_ui_height;
6175 max_rows = w_zone_height - 2;
6176 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6177 point( offsetX + 1, 1 ) );
6178 w_zones_border = catacurses::newwin( w_zone_height, width,
6179 point( offsetX, 0 ) );
6180 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6181 width - 2, point( offsetX + 1, w_zone_height ) );
6182 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6183 point( offsetX, w_zone_height ) );
6184 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6185 point( offsetX + 1, TERMY - zone_options_height ) );
6186
6187 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6188 } );
6189 ui.mark_resize();
6190
6191 std::string action;
6192 input_context ctxt( "ZONES_MANAGER" );
6193 ctxt.register_cardinal();
6194 ctxt.register_action( "CONFIRM" );
6195 ctxt.register_action( "QUIT" );
6196 ctxt.register_action( "ADD_ZONE" );
6197 ctxt.register_action( "REMOVE_ZONE" );
6198 ctxt.register_action( "MOVE_ZONE_UP" );
6199 ctxt.register_action( "MOVE_ZONE_DOWN" );
6200 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6201 ctxt.register_action( "ENABLE_ZONE" );
6202 ctxt.register_action( "DISABLE_ZONE" );
6203 ctxt.register_action( "SHOW_ALL_ZONES" );
6204 ctxt.register_action( "HELP_KEYBINDINGS" );
6205
6206 auto &mgr = zone_manager::get_manager();
6207 int start_index = 0;
6208 int active_index = 0;
6209 bool blink = false;
6210 bool stuff_changed = false;
6211 bool show_all_zones = false;
6212 int zone_cnt = 0;
6213
6214 // get zones on the same z-level, with distance between player and
6215 // zone center point <= 50 or all zones, if show_all_zones is true
6216 auto get_zones = [&]() {
6217 std::vector<zone_manager::ref_zone_data> zones;
6218 if( show_all_zones ) {
6219 zones = mgr.get_zones();
6220 } else {
6221 const tripoint &u_abs_pos = m.getabs( u.pos() );
6222 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6223 const tripoint &zone_abs_pos = ref.get().get_center_point();
6224 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6225 zones.emplace_back( ref );
6226 }
6227 }
6228 }
6229 zone_cnt = static_cast<int>( zones.size() );
6230 return zones;
6231 };
6232
6233 auto zones = get_zones();
6234
6235 auto zones_manager_options = [&]() {
6236 werase( w_zones_options );
6237
6238 if( zone_cnt > 0 ) {
6239 const auto &zone = zones[active_index].get();
6240
6241 if( zone.has_options() ) {
6242 const auto &descriptions = zone.get_options().get_descriptions();
6243
6244 // NOLINTNEXTLINE(cata-use-named-point-constants)
6245 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6246
6247 int y = 1;
6248 for( const auto &desc : descriptions ) {
6249 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6250 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6251 y++;
6252 }
6253 }
6254 }
6255
6256 wnoutrefresh( w_zones_options );
6257 };
6258
6259 cata::optional<tripoint> zone_start;
6260 cata::optional<tripoint> zone_end;
6261 bool zone_blink = false;
6262 bool zone_cursor = false;
6264 zone_start, zone_end, zone_blink, zone_cursor );
6265 add_draw_callback( zone_cb );
6266
6267 auto query_position =
6268 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6269 on_out_of_scope invalidate_current_ui( [&]()
6270 {
6271 ui.mark_resize();
6272 } );
6273 restore_on_out_of_scope<bool> show_prev( show );
6274 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6275 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6276 show = false;
6277 zone_start = cata::nullopt;
6278 zone_end = cata::nullopt;
6279 ui.mark_resize();
6280
6282 popup.on_top( true );
6283 popup.message( "%s", _( "Select first point." ) );
6284
6286
6287 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6288 false );
6289 if( first.position )
6290 {
6291 popup.message( "%s", _( "Select second point." ) );
6292
6293 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6294 true, true, false );
6295 if( second.position ) {
6296 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6297 second.position->x ),
6298 std::min( first.position->y, second.position->y ),
6299 std::min( first.position->z,
6300 second.position->z ) ) );
6301 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6302 second.position->x ),
6303 std::max( first.position->y, second.position->y ),
6304 std::max( first.position->z,
6305 second.position->z ) ) );
6306 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6307 }
6308 }
6309
6310 return cata::nullopt;
6311 };
6312
6313 ui.on_redraw( [&]( const ui_adaptor & ) {
6314 if( !show ) {
6315 return;
6316 }
6317 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6318 zones_manager_shortcuts( w_zones_info );
6319
6320 if( zone_cnt == 0 ) {
6321 werase( w_zones );
6322 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6323
6324 } else {
6325 werase( w_zones );
6326
6327 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6328
6329 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6330 wnoutrefresh( w_zones_border );
6331
6332 int iNum = 0;
6333
6334 tripoint player_absolute_pos = m.getabs( u.pos() );
6335
6336 //Display saved zones
6337 for( auto &i : zones ) {
6338 if( iNum >= start_index &&
6339 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6340 const auto &zone = i.get();
6341
6342 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6343
6344 if( iNum == active_index ) {
6345 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6346 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6347 }
6348
6349 //Draw Zone name
6350 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6351 trim_by_length( zone.get_name(), 15 ) );
6352
6353 //Draw Type name
6354 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6355 mgr.get_name_from_type( zone.get_type() ) );
6356
6357 tripoint center = zone.get_center_point();
6358
6359 //Draw direction + distance
6360 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6361 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6362 direction_name_short( direction_from( player_absolute_pos,
6363 center ) ) );
6364
6365 //Draw Vehicle Indicator
6366 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6367 zone.get_is_vehicle() ? "*" : "" );
6368 }
6369 iNum++;
6370 }
6371
6372 // Display zone options
6373 zones_manager_options();
6374 }
6375
6376 wnoutrefresh( w_zones );
6377 } );
6378
6379 zones_manager_open = true;
6380 do {
6381 if( action == "ADD_ZONE" ) {
6382 do { // not a loop, just for quick bailing out if canceled
6383 const auto maybe_id = mgr.query_type();
6384 if( !maybe_id.has_value() ) {
6385 break;
6386 }
6387
6388 const zone_type_id &id = maybe_id.value();
6389 auto options = zone_options::create( id );
6390
6391 if( !options->query_at_creation() ) {
6392 break;
6393 }
6394
6395 auto default_name = options->get_zone_name_suggestion();
6396 if( default_name.empty() ) {
6397 default_name = mgr.get_name_from_type( id );
6398 }
6399 const auto maybe_name = mgr.query_name( default_name );
6400 if( !maybe_name.has_value() ) {
6401 break;
6402 }
6403 const std::string &name = maybe_name.value();
6404
6405 const auto position = query_position();
6406 if( !position ) {
6407 break;
6408 }
6409
6410 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6411 position->second, options );
6412
6413 zones = get_zones();
6414 active_index = zone_cnt - 1;
6415
6416 stuff_changed = true;
6417 } while( false );
6418
6419 blink = false;
6420 } else if( action == "SHOW_ALL_ZONES" ) {
6421 show_all_zones = !show_all_zones;
6422 zones = get_zones();
6423 active_index = 0;
6424 } else if( zone_cnt > 0 ) {
6425 if( action == "UP" ) {
6426 active_index--;
6427 if( active_index < 0 ) {
6428 active_index = zone_cnt - 1;
6429 }
6430 blink = false;
6431 } else if( action == "DOWN" ) {
6432 active_index++;
6433 if( active_index >= zone_cnt ) {
6434 active_index = 0;
6435 }
6436 blink = false;
6437 } else if( action == "REMOVE_ZONE" ) {
6438 if( active_index < zone_cnt ) {
6439 mgr.remove( zones[active_index] );
6440 zones = get_zones();
6441 active_index--;
6442
6443 if( active_index < 0 ) {
6444 active_index = 0;
6445 }
6446 }
6447 blink = false;
6448 stuff_changed = true;
6449
6450 } else if( action == "CONFIRM" ) {
6451 auto &zone = zones[active_index].get();
6452
6453 uilist as_m;
6454 as_m.text = _( "What do you want to change:" );
6455 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6456 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6457 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6458 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6459 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6460 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6461 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6462 as_m.query();
6463
6464 switch( as_m.ret ) {
6465 case 1:
6466 if( zone.set_name() ) {
6467 stuff_changed = true;
6468 }
6469 break;
6470 case 2:
6471 if( zone.set_type() ) {
6472 stuff_changed = true;
6473 }
6474 break;
6475 case 3:
6476 if( zone.get_options().query() ) {
6477 stuff_changed = true;
6478 }
6479 break;
6480 case 4: {
6481 const auto pos = query_position();
6482 if( pos && ( pos->first != zone.get_start_point() ||
6483 pos->second != zone.get_end_point() ) ) {
6484 zone.set_position( *pos );
6485 stuff_changed = true;
6486 }
6487 break;
6488 }
6489 case 5: {
6490 on_out_of_scope invalidate_current_ui( [&]() {
6491 ui.mark_resize();
6492 } );
6493 restore_on_out_of_scope<bool> show_prev( show );
6494 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6495 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6496 show = false;
6497 zone_start = cata::nullopt;
6498 zone_end = cata::nullopt;
6499 ui.mark_resize();
6500 static_popup message_pop;
6501 message_pop.on_top( true );
6502 message_pop.message( "%s", _( "Moving zone." ) );
6503 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6504 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6505 // local position of the zone center, used to calculate the u.view_offset,
6506 // could center the screen to the position it represents
6507 auto view_center = m.getlocal( zone.get_center_point() );
6508 const look_around_result result_local = look_around( false, view_center,
6509 zone_local_start_point, false, false,
6510 false, true, zone_local_end_point );
6511 if( result_local.position ) {
6512 const auto new_start_point = m.getabs( *result_local.position );
6513 if( new_start_point == zone.get_start_point() ) {
6514 break; // Nothing changed, don't save
6515 }
6516
6517 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6518 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6519 stuff_changed = true;
6520 }
6521 }
6522 break;
6523 default:
6524 break;
6525 }
6526
6527 blink = false;
6528 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6529 if( active_index < zone_cnt - 1 ) {
6530 mgr.swap( zones[active_index], zones[active_index + 1] );
6531 zones = get_zones();
6532 active_index++;
6533 }
6534 blink = false;
6535 stuff_changed = true;
6536
6537 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6538 if( active_index > 0 ) {
6539 mgr.swap( zones[active_index], zones[active_index - 1] );
6540 zones = get_zones();
6541 active_index--;
6542 }
6543 blink = false;
6544 stuff_changed = true;
6545
6546 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6547 //show zone position on overmap;
6548 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6549 // TODO: fix point types
6550 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6551
6552 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6553 } else if( action == "ENABLE_ZONE" ) {
6554 zones[active_index].get().set_enabled( true );
6555
6556 stuff_changed = true;
6557
6558 } else if( action == "DISABLE_ZONE" ) {
6559 zones[active_index].get().set_enabled( false );
6560
6561 stuff_changed = true;
6562 }
6563 }
6564
6565 if( zone_cnt > 0 ) {
6566 blink = !blink;
6567 const auto &zone = zones[active_index].get();
6568 zone_start = m.getlocal( zone.get_start_point() );
6569 zone_end = m.getlocal( zone.get_end_point() );
6570 ctxt.set_timeout( BLINK_SPEED );
6571 } else {
6572 blink = false;
6573 zone_start = zone_end = cata::nullopt;
6574 ctxt.reset_timeout();
6575 }
6576
6577 // Actually accessed from the terrain overlay callback `zone_cb` in the
6578 // call to `ui_manager::redraw`.
6579 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6580 zone_blink = blink;
6582
6584
6585 //Wait for input
6586 action = ctxt.handle_input();
6587 } while( action != "QUIT" );
6588 zones_manager_open = false;
6589 ctxt.reset_timeout();
6590 zone_cb = nullptr;
6591
6592 if( stuff_changed ) {
6593 auto &zones = zone_manager::get_manager();
6594 if( query_yn( _( "Save changes?" ) ) ) {
6595 zones.save_zones();
6596 } else {
6597 zones.load_zones();
6598 }
6599
6600 zones.cache_data();
6601 }
6602
6603 u.view_offset = stored_view_offset;
6604}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:345
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:185
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6079
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6102
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7098 of file game.cpp.

7099{
7100#if defined(TILES)
7101 if( tileset_zoom == 64 ) {
7102 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7103 } else {
7105 }
7106 rescale_tileset( tileset_zoom );
7107#endif
7108}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7086 of file game.cpp.

7087{
7088#if defined(TILES)
7089 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7091 } else {
7092 tileset_zoom = 64;
7093 }
7094 rescale_tileset( tileset_zoom );
7095#endif
7096}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 102 of file avatar.cpp.

103{
104 return g->u;
105}

Referenced by butcher_submenu().

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12089 of file game.cpp.

12090{
12091 return *g->grid_tracker_ptr;
12092}

◆ get_map

map & get_map ( )
friend

Definition at line 142 of file map.cpp.

143{
144 return g->m;
145}

Referenced by check_art_charge_req(), extended_description(), find_empty_spot_nearby(), get_fire_fuel_string(), and print_terrain_info().

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 387 of file character.cpp.

388{
389 return g->u;
390}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 976 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1039 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1056 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1070 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1020 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1021 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1033 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 940 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1031 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1018 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 974 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1072 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 980 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 977 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1089 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1091 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1090 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1062 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1063 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1053 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1052 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 971 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 970 of file game.h.

◆ m

map& game::m

Definition at line 984 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 968 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 978 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1005 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1061 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1001 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1059 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1057 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1068 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1040 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1066 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1065 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1036 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1055 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1003 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 986 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 972 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1084 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1051 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1035 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 979 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 975 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1007 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1081 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 973 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 987 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 996 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1042 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 985 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), open_gate(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 969 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1046 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 999 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1078 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1011 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1049 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1010 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1009 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1048 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1097 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1038 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 981 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1074 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: